
/**
 * This is a generated class and is not intended for modification.  
 */
package valueObjects
{
import com.adobe.fiber.styles.IStyle;
import com.adobe.fiber.styles.Style;
import com.adobe.fiber.styles.StyleValidator;
import com.adobe.fiber.valueobjects.AbstractEntityMetadata;
import com.adobe.fiber.valueobjects.AvailablePropertyIterator;
import com.adobe.fiber.valueobjects.IPropertyIterator;
import mx.events.ValidationResultEvent;
import com.adobe.fiber.core.model_internal;
import com.adobe.fiber.valueobjects.IModelType;
import mx.events.PropertyChangeEvent;

use namespace model_internal;

[ExcludeClass]
internal class _ConstructionsEntityMetadata extends com.adobe.fiber.valueobjects.AbstractEntityMetadata
{
    private static var emptyArray:Array = new Array();

    model_internal static var allProperties:Array = new Array("partnerFS", "userFS", "published", "int_id_climate", "int_id_kind", "int_id_static", "int_id_facade", "int_id_construction", "int_id_joint", "int_id_no", "int_id_localisation", "version_nr", "valid_since", "valid_to", "image", "image_caption", "url_dxf", "url_dwg", "url_pla", "url_pdf", "url_jpg", "rw", "lntw", "rei", "notes", "physics", "add_notes", "rel_info", "layer_a_dimensions", "layer_b_dimensions", "layer_c_dimensions", "constr_id", "u_value_a", "u_value_b", "layer_b_names", "u_value_c", "u_value_d", "int_id_summary", "system", "name", "layer_c_names", "active_tab", "layer_d_names", "layer_d_dimensions", "layer_a_names");
    model_internal static var allAssociationProperties:Array = new Array();
    model_internal static var allRequiredProperties:Array = new Array("partnerFS", "userFS", "published", "int_id_climate", "int_id_kind", "int_id_static", "int_id_facade", "int_id_construction", "int_id_joint", "int_id_no", "int_id_localisation", "version_nr", "valid_since", "valid_to", "image", "image_caption", "url_dxf", "url_dwg", "url_pla", "url_pdf", "url_jpg", "rw", "lntw", "rei", "notes", "physics", "add_notes", "rel_info", "layer_a_dimensions", "layer_b_dimensions", "layer_c_dimensions", "constr_id", "u_value_a", "u_value_b", "layer_b_names", "u_value_c", "u_value_d", "int_id_summary", "system", "name", "layer_c_names", "active_tab", "layer_d_names", "layer_d_dimensions", "layer_a_names");
    model_internal static var allAlwaysAvailableProperties:Array = new Array("partnerFS", "userFS", "published", "int_id_climate", "int_id_kind", "int_id_static", "int_id_facade", "int_id_construction", "int_id_joint", "int_id_no", "int_id_localisation", "version_nr", "valid_since", "valid_to", "image", "image_caption", "url_dxf", "url_dwg", "url_pla", "url_pdf", "url_jpg", "rw", "lntw", "rei", "notes", "physics", "add_notes", "rel_info", "layer_a_dimensions", "layer_b_dimensions", "layer_c_dimensions", "constr_id", "u_value_a", "u_value_b", "layer_b_names", "u_value_c", "u_value_d", "int_id_summary", "system", "name", "layer_c_names", "active_tab", "layer_d_names", "layer_d_dimensions", "layer_a_names");
    model_internal static var guardedProperties:Array = new Array();
    model_internal static var dataProperties:Array = new Array("partnerFS", "userFS", "published", "int_id_climate", "int_id_kind", "int_id_static", "int_id_facade", "int_id_construction", "int_id_joint", "int_id_no", "int_id_localisation", "version_nr", "valid_since", "valid_to", "image", "image_caption", "url_dxf", "url_dwg", "url_pla", "url_pdf", "url_jpg", "rw", "lntw", "rei", "notes", "physics", "add_notes", "rel_info", "layer_a_dimensions", "layer_b_dimensions", "layer_c_dimensions", "constr_id", "u_value_a", "u_value_b", "layer_b_names", "u_value_c", "u_value_d", "int_id_summary", "system", "name", "layer_c_names", "active_tab", "layer_d_names", "layer_d_dimensions", "layer_a_names");
    model_internal static var sourceProperties:Array = emptyArray
    model_internal static var nonDerivedProperties:Array = new Array("partnerFS", "userFS", "published", "int_id_climate", "int_id_kind", "int_id_static", "int_id_facade", "int_id_construction", "int_id_joint", "int_id_no", "int_id_localisation", "version_nr", "valid_since", "valid_to", "image", "image_caption", "url_dxf", "url_dwg", "url_pla", "url_pdf", "url_jpg", "rw", "lntw", "rei", "notes", "physics", "add_notes", "rel_info", "layer_a_dimensions", "layer_b_dimensions", "layer_c_dimensions", "constr_id", "u_value_a", "u_value_b", "layer_b_names", "u_value_c", "u_value_d", "int_id_summary", "system", "name", "layer_c_names", "active_tab", "layer_d_names", "layer_d_dimensions", "layer_a_names");
    model_internal static var derivedProperties:Array = new Array();
    model_internal static var collectionProperties:Array = new Array();
    model_internal static var collectionBaseMap:Object;
    model_internal static var entityName:String = "Constructions";
    model_internal static var dependentsOnMap:Object;
    model_internal static var dependedOnServices:Array = new Array();
    model_internal static var propertyTypeMap:Object;

    
    model_internal var _partnerFSIsValid:Boolean;
    model_internal var _partnerFSValidator:com.adobe.fiber.styles.StyleValidator;
    model_internal var _partnerFSIsValidCacheInitialized:Boolean = false;
    model_internal var _partnerFSValidationFailureMessages:Array;
    
    model_internal var _publishedIsValid:Boolean;
    model_internal var _publishedValidator:com.adobe.fiber.styles.StyleValidator;
    model_internal var _publishedIsValidCacheInitialized:Boolean = false;
    model_internal var _publishedValidationFailureMessages:Array;
    
    model_internal var _int_id_climateIsValid:Boolean;
    model_internal var _int_id_climateValidator:com.adobe.fiber.styles.StyleValidator;
    model_internal var _int_id_climateIsValidCacheInitialized:Boolean = false;
    model_internal var _int_id_climateValidationFailureMessages:Array;
    
    model_internal var _int_id_kindIsValid:Boolean;
    model_internal var _int_id_kindValidator:com.adobe.fiber.styles.StyleValidator;
    model_internal var _int_id_kindIsValidCacheInitialized:Boolean = false;
    model_internal var _int_id_kindValidationFailureMessages:Array;
    
    model_internal var _int_id_staticIsValid:Boolean;
    model_internal var _int_id_staticValidator:com.adobe.fiber.styles.StyleValidator;
    model_internal var _int_id_staticIsValidCacheInitialized:Boolean = false;
    model_internal var _int_id_staticValidationFailureMessages:Array;
    
    model_internal var _int_id_facadeIsValid:Boolean;
    model_internal var _int_id_facadeValidator:com.adobe.fiber.styles.StyleValidator;
    model_internal var _int_id_facadeIsValidCacheInitialized:Boolean = false;
    model_internal var _int_id_facadeValidationFailureMessages:Array;
    
    model_internal var _int_id_jointIsValid:Boolean;
    model_internal var _int_id_jointValidator:com.adobe.fiber.styles.StyleValidator;
    model_internal var _int_id_jointIsValidCacheInitialized:Boolean = false;
    model_internal var _int_id_jointValidationFailureMessages:Array;
    
    model_internal var _int_id_noIsValid:Boolean;
    model_internal var _int_id_noValidator:com.adobe.fiber.styles.StyleValidator;
    model_internal var _int_id_noIsValidCacheInitialized:Boolean = false;
    model_internal var _int_id_noValidationFailureMessages:Array;
    
    model_internal var _int_id_localisationIsValid:Boolean;
    model_internal var _int_id_localisationValidator:com.adobe.fiber.styles.StyleValidator;
    model_internal var _int_id_localisationIsValidCacheInitialized:Boolean = false;
    model_internal var _int_id_localisationValidationFailureMessages:Array;
    
    model_internal var _valid_sinceIsValid:Boolean;
    model_internal var _valid_sinceValidator:com.adobe.fiber.styles.StyleValidator;
    model_internal var _valid_sinceIsValidCacheInitialized:Boolean = false;
    model_internal var _valid_sinceValidationFailureMessages:Array;
    
    model_internal var _valid_toIsValid:Boolean;
    model_internal var _valid_toValidator:com.adobe.fiber.styles.StyleValidator;
    model_internal var _valid_toIsValidCacheInitialized:Boolean = false;
    model_internal var _valid_toValidationFailureMessages:Array;
    
    model_internal var _imageIsValid:Boolean;
    model_internal var _imageValidator:com.adobe.fiber.styles.StyleValidator;
    model_internal var _imageIsValidCacheInitialized:Boolean = false;
    model_internal var _imageValidationFailureMessages:Array;
    
    model_internal var _image_captionIsValid:Boolean;
    model_internal var _image_captionValidator:com.adobe.fiber.styles.StyleValidator;
    model_internal var _image_captionIsValidCacheInitialized:Boolean = false;
    model_internal var _image_captionValidationFailureMessages:Array;
    
    model_internal var _url_dxfIsValid:Boolean;
    model_internal var _url_dxfValidator:com.adobe.fiber.styles.StyleValidator;
    model_internal var _url_dxfIsValidCacheInitialized:Boolean = false;
    model_internal var _url_dxfValidationFailureMessages:Array;
    
    model_internal var _url_dwgIsValid:Boolean;
    model_internal var _url_dwgValidator:com.adobe.fiber.styles.StyleValidator;
    model_internal var _url_dwgIsValidCacheInitialized:Boolean = false;
    model_internal var _url_dwgValidationFailureMessages:Array;
    
    model_internal var _url_plaIsValid:Boolean;
    model_internal var _url_plaValidator:com.adobe.fiber.styles.StyleValidator;
    model_internal var _url_plaIsValidCacheInitialized:Boolean = false;
    model_internal var _url_plaValidationFailureMessages:Array;
    
    model_internal var _url_pdfIsValid:Boolean;
    model_internal var _url_pdfValidator:com.adobe.fiber.styles.StyleValidator;
    model_internal var _url_pdfIsValidCacheInitialized:Boolean = false;
    model_internal var _url_pdfValidationFailureMessages:Array;
    
    model_internal var _url_jpgIsValid:Boolean;
    model_internal var _url_jpgValidator:com.adobe.fiber.styles.StyleValidator;
    model_internal var _url_jpgIsValidCacheInitialized:Boolean = false;
    model_internal var _url_jpgValidationFailureMessages:Array;
    
    model_internal var _rwIsValid:Boolean;
    model_internal var _rwValidator:com.adobe.fiber.styles.StyleValidator;
    model_internal var _rwIsValidCacheInitialized:Boolean = false;
    model_internal var _rwValidationFailureMessages:Array;
    
    model_internal var _lntwIsValid:Boolean;
    model_internal var _lntwValidator:com.adobe.fiber.styles.StyleValidator;
    model_internal var _lntwIsValidCacheInitialized:Boolean = false;
    model_internal var _lntwValidationFailureMessages:Array;
    
    model_internal var _notesIsValid:Boolean;
    model_internal var _notesValidator:com.adobe.fiber.styles.StyleValidator;
    model_internal var _notesIsValidCacheInitialized:Boolean = false;
    model_internal var _notesValidationFailureMessages:Array;
    
    model_internal var _physicsIsValid:Boolean;
    model_internal var _physicsValidator:com.adobe.fiber.styles.StyleValidator;
    model_internal var _physicsIsValidCacheInitialized:Boolean = false;
    model_internal var _physicsValidationFailureMessages:Array;
    
    model_internal var _add_notesIsValid:Boolean;
    model_internal var _add_notesValidator:com.adobe.fiber.styles.StyleValidator;
    model_internal var _add_notesIsValidCacheInitialized:Boolean = false;
    model_internal var _add_notesValidationFailureMessages:Array;
    
    model_internal var _rel_infoIsValid:Boolean;
    model_internal var _rel_infoValidator:com.adobe.fiber.styles.StyleValidator;
    model_internal var _rel_infoIsValidCacheInitialized:Boolean = false;
    model_internal var _rel_infoValidationFailureMessages:Array;
    
    model_internal var _layer_a_dimensionsIsValid:Boolean;
    model_internal var _layer_a_dimensionsValidator:com.adobe.fiber.styles.StyleValidator;
    model_internal var _layer_a_dimensionsIsValidCacheInitialized:Boolean = false;
    model_internal var _layer_a_dimensionsValidationFailureMessages:Array;
    
    model_internal var _layer_b_dimensionsIsValid:Boolean;
    model_internal var _layer_b_dimensionsValidator:com.adobe.fiber.styles.StyleValidator;
    model_internal var _layer_b_dimensionsIsValidCacheInitialized:Boolean = false;
    model_internal var _layer_b_dimensionsValidationFailureMessages:Array;
    
    model_internal var _layer_c_dimensionsIsValid:Boolean;
    model_internal var _layer_c_dimensionsValidator:com.adobe.fiber.styles.StyleValidator;
    model_internal var _layer_c_dimensionsIsValidCacheInitialized:Boolean = false;
    model_internal var _layer_c_dimensionsValidationFailureMessages:Array;
    
    model_internal var _layer_b_namesIsValid:Boolean;
    model_internal var _layer_b_namesValidator:com.adobe.fiber.styles.StyleValidator;
    model_internal var _layer_b_namesIsValidCacheInitialized:Boolean = false;
    model_internal var _layer_b_namesValidationFailureMessages:Array;
    
    model_internal var _int_id_summaryIsValid:Boolean;
    model_internal var _int_id_summaryValidator:com.adobe.fiber.styles.StyleValidator;
    model_internal var _int_id_summaryIsValidCacheInitialized:Boolean = false;
    model_internal var _int_id_summaryValidationFailureMessages:Array;
    
    model_internal var _systemIsValid:Boolean;
    model_internal var _systemValidator:com.adobe.fiber.styles.StyleValidator;
    model_internal var _systemIsValidCacheInitialized:Boolean = false;
    model_internal var _systemValidationFailureMessages:Array;
    
    model_internal var _nameIsValid:Boolean;
    model_internal var _nameValidator:com.adobe.fiber.styles.StyleValidator;
    model_internal var _nameIsValidCacheInitialized:Boolean = false;
    model_internal var _nameValidationFailureMessages:Array;
    
    model_internal var _layer_c_namesIsValid:Boolean;
    model_internal var _layer_c_namesValidator:com.adobe.fiber.styles.StyleValidator;
    model_internal var _layer_c_namesIsValidCacheInitialized:Boolean = false;
    model_internal var _layer_c_namesValidationFailureMessages:Array;
    
    model_internal var _layer_d_namesIsValid:Boolean;
    model_internal var _layer_d_namesValidator:com.adobe.fiber.styles.StyleValidator;
    model_internal var _layer_d_namesIsValidCacheInitialized:Boolean = false;
    model_internal var _layer_d_namesValidationFailureMessages:Array;
    
    model_internal var _layer_d_dimensionsIsValid:Boolean;
    model_internal var _layer_d_dimensionsValidator:com.adobe.fiber.styles.StyleValidator;
    model_internal var _layer_d_dimensionsIsValidCacheInitialized:Boolean = false;
    model_internal var _layer_d_dimensionsValidationFailureMessages:Array;
    
    model_internal var _layer_a_namesIsValid:Boolean;
    model_internal var _layer_a_namesValidator:com.adobe.fiber.styles.StyleValidator;
    model_internal var _layer_a_namesIsValidCacheInitialized:Boolean = false;
    model_internal var _layer_a_namesValidationFailureMessages:Array;

    model_internal var _instance:_Super_Constructions;
    model_internal static var _nullStyle:com.adobe.fiber.styles.Style = new com.adobe.fiber.styles.Style();

    public function _ConstructionsEntityMetadata(value : _Super_Constructions)
    {
        // initialize property maps
        if (model_internal::dependentsOnMap == null)
        {
            // dependents map
            model_internal::dependentsOnMap = new Object();
            model_internal::dependentsOnMap["partnerFS"] = new Array();
            model_internal::dependentsOnMap["userFS"] = new Array();
            model_internal::dependentsOnMap["published"] = new Array();
            model_internal::dependentsOnMap["int_id_climate"] = new Array();
            model_internal::dependentsOnMap["int_id_kind"] = new Array();
            model_internal::dependentsOnMap["int_id_static"] = new Array();
            model_internal::dependentsOnMap["int_id_facade"] = new Array();
            model_internal::dependentsOnMap["int_id_construction"] = new Array();
            model_internal::dependentsOnMap["int_id_joint"] = new Array();
            model_internal::dependentsOnMap["int_id_no"] = new Array();
            model_internal::dependentsOnMap["int_id_localisation"] = new Array();
            model_internal::dependentsOnMap["version_nr"] = new Array();
            model_internal::dependentsOnMap["valid_since"] = new Array();
            model_internal::dependentsOnMap["valid_to"] = new Array();
            model_internal::dependentsOnMap["image"] = new Array();
            model_internal::dependentsOnMap["image_caption"] = new Array();
            model_internal::dependentsOnMap["url_dxf"] = new Array();
            model_internal::dependentsOnMap["url_dwg"] = new Array();
            model_internal::dependentsOnMap["url_pla"] = new Array();
            model_internal::dependentsOnMap["url_pdf"] = new Array();
            model_internal::dependentsOnMap["url_jpg"] = new Array();
            model_internal::dependentsOnMap["rw"] = new Array();
            model_internal::dependentsOnMap["lntw"] = new Array();
            model_internal::dependentsOnMap["rei"] = new Array();
            model_internal::dependentsOnMap["notes"] = new Array();
            model_internal::dependentsOnMap["physics"] = new Array();
            model_internal::dependentsOnMap["add_notes"] = new Array();
            model_internal::dependentsOnMap["rel_info"] = new Array();
            model_internal::dependentsOnMap["layer_a_dimensions"] = new Array();
            model_internal::dependentsOnMap["layer_b_dimensions"] = new Array();
            model_internal::dependentsOnMap["layer_c_dimensions"] = new Array();
            model_internal::dependentsOnMap["constr_id"] = new Array();
            model_internal::dependentsOnMap["u_value_a"] = new Array();
            model_internal::dependentsOnMap["u_value_b"] = new Array();
            model_internal::dependentsOnMap["layer_b_names"] = new Array();
            model_internal::dependentsOnMap["u_value_c"] = new Array();
            model_internal::dependentsOnMap["u_value_d"] = new Array();
            model_internal::dependentsOnMap["int_id_summary"] = new Array();
            model_internal::dependentsOnMap["system"] = new Array();
            model_internal::dependentsOnMap["name"] = new Array();
            model_internal::dependentsOnMap["layer_c_names"] = new Array();
            model_internal::dependentsOnMap["active_tab"] = new Array();
            model_internal::dependentsOnMap["layer_d_names"] = new Array();
            model_internal::dependentsOnMap["layer_d_dimensions"] = new Array();
            model_internal::dependentsOnMap["layer_a_names"] = new Array();

            // collection base map
            model_internal::collectionBaseMap = new Object();
        }

        // Property type Map
        model_internal::propertyTypeMap = new Object();
        model_internal::propertyTypeMap["partnerFS"] = "String";
        model_internal::propertyTypeMap["userFS"] = "int";
        model_internal::propertyTypeMap["published"] = "String";
        model_internal::propertyTypeMap["int_id_climate"] = "String";
        model_internal::propertyTypeMap["int_id_kind"] = "String";
        model_internal::propertyTypeMap["int_id_static"] = "String";
        model_internal::propertyTypeMap["int_id_facade"] = "String";
        model_internal::propertyTypeMap["int_id_construction"] = "int";
        model_internal::propertyTypeMap["int_id_joint"] = "String";
        model_internal::propertyTypeMap["int_id_no"] = "String";
        model_internal::propertyTypeMap["int_id_localisation"] = "String";
        model_internal::propertyTypeMap["version_nr"] = "int";
        model_internal::propertyTypeMap["valid_since"] = "Date";
        model_internal::propertyTypeMap["valid_to"] = "Date";
        model_internal::propertyTypeMap["image"] = "String";
        model_internal::propertyTypeMap["image_caption"] = "String";
        model_internal::propertyTypeMap["url_dxf"] = "String";
        model_internal::propertyTypeMap["url_dwg"] = "String";
        model_internal::propertyTypeMap["url_pla"] = "String";
        model_internal::propertyTypeMap["url_pdf"] = "String";
        model_internal::propertyTypeMap["url_jpg"] = "String";
        model_internal::propertyTypeMap["rw"] = "String";
        model_internal::propertyTypeMap["lntw"] = "String";
        model_internal::propertyTypeMap["rei"] = "int";
        model_internal::propertyTypeMap["notes"] = "String";
        model_internal::propertyTypeMap["physics"] = "String";
        model_internal::propertyTypeMap["add_notes"] = "String";
        model_internal::propertyTypeMap["rel_info"] = "String";
        model_internal::propertyTypeMap["layer_a_dimensions"] = "String";
        model_internal::propertyTypeMap["layer_b_dimensions"] = "String";
        model_internal::propertyTypeMap["layer_c_dimensions"] = "String";
        model_internal::propertyTypeMap["constr_id"] = "int";
        model_internal::propertyTypeMap["u_value_a"] = "Number";
        model_internal::propertyTypeMap["u_value_b"] = "Number";
        model_internal::propertyTypeMap["layer_b_names"] = "String";
        model_internal::propertyTypeMap["u_value_c"] = "Number";
        model_internal::propertyTypeMap["u_value_d"] = "Number";
        model_internal::propertyTypeMap["int_id_summary"] = "String";
        model_internal::propertyTypeMap["system"] = "String";
        model_internal::propertyTypeMap["name"] = "String";
        model_internal::propertyTypeMap["layer_c_names"] = "String";
        model_internal::propertyTypeMap["active_tab"] = "int";
        model_internal::propertyTypeMap["layer_d_names"] = "String";
        model_internal::propertyTypeMap["layer_d_dimensions"] = "String";
        model_internal::propertyTypeMap["layer_a_names"] = "String";

        model_internal::_instance = value;
        model_internal::_partnerFSValidator = new StyleValidator(model_internal::_instance.model_internal::_doValidationForPartnerFS);
        model_internal::_partnerFSValidator.required = true;
        model_internal::_partnerFSValidator.requiredFieldError = "partnerFS is required";
        //model_internal::_partnerFSValidator.source = model_internal::_instance;
        //model_internal::_partnerFSValidator.property = "partnerFS";
        model_internal::_publishedValidator = new StyleValidator(model_internal::_instance.model_internal::_doValidationForPublished);
        model_internal::_publishedValidator.required = true;
        model_internal::_publishedValidator.requiredFieldError = "published is required";
        //model_internal::_publishedValidator.source = model_internal::_instance;
        //model_internal::_publishedValidator.property = "published";
        model_internal::_int_id_climateValidator = new StyleValidator(model_internal::_instance.model_internal::_doValidationForInt_id_climate);
        model_internal::_int_id_climateValidator.required = true;
        model_internal::_int_id_climateValidator.requiredFieldError = "int_id_climate is required";
        //model_internal::_int_id_climateValidator.source = model_internal::_instance;
        //model_internal::_int_id_climateValidator.property = "int_id_climate";
        model_internal::_int_id_kindValidator = new StyleValidator(model_internal::_instance.model_internal::_doValidationForInt_id_kind);
        model_internal::_int_id_kindValidator.required = true;
        model_internal::_int_id_kindValidator.requiredFieldError = "int_id_kind is required";
        //model_internal::_int_id_kindValidator.source = model_internal::_instance;
        //model_internal::_int_id_kindValidator.property = "int_id_kind";
        model_internal::_int_id_staticValidator = new StyleValidator(model_internal::_instance.model_internal::_doValidationForInt_id_static);
        model_internal::_int_id_staticValidator.required = true;
        model_internal::_int_id_staticValidator.requiredFieldError = "int_id_static is required";
        //model_internal::_int_id_staticValidator.source = model_internal::_instance;
        //model_internal::_int_id_staticValidator.property = "int_id_static";
        model_internal::_int_id_facadeValidator = new StyleValidator(model_internal::_instance.model_internal::_doValidationForInt_id_facade);
        model_internal::_int_id_facadeValidator.required = true;
        model_internal::_int_id_facadeValidator.requiredFieldError = "int_id_facade is required";
        //model_internal::_int_id_facadeValidator.source = model_internal::_instance;
        //model_internal::_int_id_facadeValidator.property = "int_id_facade";
        model_internal::_int_id_jointValidator = new StyleValidator(model_internal::_instance.model_internal::_doValidationForInt_id_joint);
        model_internal::_int_id_jointValidator.required = true;
        model_internal::_int_id_jointValidator.requiredFieldError = "int_id_joint is required";
        //model_internal::_int_id_jointValidator.source = model_internal::_instance;
        //model_internal::_int_id_jointValidator.property = "int_id_joint";
        model_internal::_int_id_noValidator = new StyleValidator(model_internal::_instance.model_internal::_doValidationForInt_id_no);
        model_internal::_int_id_noValidator.required = true;
        model_internal::_int_id_noValidator.requiredFieldError = "int_id_no is required";
        //model_internal::_int_id_noValidator.source = model_internal::_instance;
        //model_internal::_int_id_noValidator.property = "int_id_no";
        model_internal::_int_id_localisationValidator = new StyleValidator(model_internal::_instance.model_internal::_doValidationForInt_id_localisation);
        model_internal::_int_id_localisationValidator.required = true;
        model_internal::_int_id_localisationValidator.requiredFieldError = "int_id_localisation is required";
        //model_internal::_int_id_localisationValidator.source = model_internal::_instance;
        //model_internal::_int_id_localisationValidator.property = "int_id_localisation";
        model_internal::_valid_sinceValidator = new StyleValidator(model_internal::_instance.model_internal::_doValidationForValid_since);
        model_internal::_valid_sinceValidator.required = true;
        model_internal::_valid_sinceValidator.requiredFieldError = "valid_since is required";
        //model_internal::_valid_sinceValidator.source = model_internal::_instance;
        //model_internal::_valid_sinceValidator.property = "valid_since";
        model_internal::_valid_toValidator = new StyleValidator(model_internal::_instance.model_internal::_doValidationForValid_to);
        model_internal::_valid_toValidator.required = true;
        model_internal::_valid_toValidator.requiredFieldError = "valid_to is required";
        //model_internal::_valid_toValidator.source = model_internal::_instance;
        //model_internal::_valid_toValidator.property = "valid_to";
        model_internal::_imageValidator = new StyleValidator(model_internal::_instance.model_internal::_doValidationForImage);
        model_internal::_imageValidator.required = true;
        model_internal::_imageValidator.requiredFieldError = "image is required";
        //model_internal::_imageValidator.source = model_internal::_instance;
        //model_internal::_imageValidator.property = "image";
        model_internal::_image_captionValidator = new StyleValidator(model_internal::_instance.model_internal::_doValidationForImage_caption);
        model_internal::_image_captionValidator.required = true;
        model_internal::_image_captionValidator.requiredFieldError = "image_caption is required";
        //model_internal::_image_captionValidator.source = model_internal::_instance;
        //model_internal::_image_captionValidator.property = "image_caption";
        model_internal::_url_dxfValidator = new StyleValidator(model_internal::_instance.model_internal::_doValidationForUrl_dxf);
        model_internal::_url_dxfValidator.required = true;
        model_internal::_url_dxfValidator.requiredFieldError = "url_dxf is required";
        //model_internal::_url_dxfValidator.source = model_internal::_instance;
        //model_internal::_url_dxfValidator.property = "url_dxf";
        model_internal::_url_dwgValidator = new StyleValidator(model_internal::_instance.model_internal::_doValidationForUrl_dwg);
        model_internal::_url_dwgValidator.required = true;
        model_internal::_url_dwgValidator.requiredFieldError = "url_dwg is required";
        //model_internal::_url_dwgValidator.source = model_internal::_instance;
        //model_internal::_url_dwgValidator.property = "url_dwg";
        model_internal::_url_plaValidator = new StyleValidator(model_internal::_instance.model_internal::_doValidationForUrl_pla);
        model_internal::_url_plaValidator.required = true;
        model_internal::_url_plaValidator.requiredFieldError = "url_pla is required";
        //model_internal::_url_plaValidator.source = model_internal::_instance;
        //model_internal::_url_plaValidator.property = "url_pla";
        model_internal::_url_pdfValidator = new StyleValidator(model_internal::_instance.model_internal::_doValidationForUrl_pdf);
        model_internal::_url_pdfValidator.required = true;
        model_internal::_url_pdfValidator.requiredFieldError = "url_pdf is required";
        //model_internal::_url_pdfValidator.source = model_internal::_instance;
        //model_internal::_url_pdfValidator.property = "url_pdf";
        model_internal::_url_jpgValidator = new StyleValidator(model_internal::_instance.model_internal::_doValidationForUrl_jpg);
        model_internal::_url_jpgValidator.required = true;
        model_internal::_url_jpgValidator.requiredFieldError = "url_jpg is required";
        //model_internal::_url_jpgValidator.source = model_internal::_instance;
        //model_internal::_url_jpgValidator.property = "url_jpg";
        model_internal::_rwValidator = new StyleValidator(model_internal::_instance.model_internal::_doValidationForRw);
        model_internal::_rwValidator.required = true;
        model_internal::_rwValidator.requiredFieldError = "rw is required";
        //model_internal::_rwValidator.source = model_internal::_instance;
        //model_internal::_rwValidator.property = "rw";
        model_internal::_lntwValidator = new StyleValidator(model_internal::_instance.model_internal::_doValidationForLntw);
        model_internal::_lntwValidator.required = true;
        model_internal::_lntwValidator.requiredFieldError = "lntw is required";
        //model_internal::_lntwValidator.source = model_internal::_instance;
        //model_internal::_lntwValidator.property = "lntw";
        model_internal::_notesValidator = new StyleValidator(model_internal::_instance.model_internal::_doValidationForNotes);
        model_internal::_notesValidator.required = true;
        model_internal::_notesValidator.requiredFieldError = "notes is required";
        //model_internal::_notesValidator.source = model_internal::_instance;
        //model_internal::_notesValidator.property = "notes";
        model_internal::_physicsValidator = new StyleValidator(model_internal::_instance.model_internal::_doValidationForPhysics);
        model_internal::_physicsValidator.required = true;
        model_internal::_physicsValidator.requiredFieldError = "physics is required";
        //model_internal::_physicsValidator.source = model_internal::_instance;
        //model_internal::_physicsValidator.property = "physics";
        model_internal::_add_notesValidator = new StyleValidator(model_internal::_instance.model_internal::_doValidationForAdd_notes);
        model_internal::_add_notesValidator.required = true;
        model_internal::_add_notesValidator.requiredFieldError = "add_notes is required";
        //model_internal::_add_notesValidator.source = model_internal::_instance;
        //model_internal::_add_notesValidator.property = "add_notes";
        model_internal::_rel_infoValidator = new StyleValidator(model_internal::_instance.model_internal::_doValidationForRel_info);
        model_internal::_rel_infoValidator.required = true;
        model_internal::_rel_infoValidator.requiredFieldError = "rel_info is required";
        //model_internal::_rel_infoValidator.source = model_internal::_instance;
        //model_internal::_rel_infoValidator.property = "rel_info";
        model_internal::_layer_a_dimensionsValidator = new StyleValidator(model_internal::_instance.model_internal::_doValidationForLayer_a_dimensions);
        model_internal::_layer_a_dimensionsValidator.required = true;
        model_internal::_layer_a_dimensionsValidator.requiredFieldError = "layer_a_dimensions is required";
        //model_internal::_layer_a_dimensionsValidator.source = model_internal::_instance;
        //model_internal::_layer_a_dimensionsValidator.property = "layer_a_dimensions";
        model_internal::_layer_b_dimensionsValidator = new StyleValidator(model_internal::_instance.model_internal::_doValidationForLayer_b_dimensions);
        model_internal::_layer_b_dimensionsValidator.required = true;
        model_internal::_layer_b_dimensionsValidator.requiredFieldError = "layer_b_dimensions is required";
        //model_internal::_layer_b_dimensionsValidator.source = model_internal::_instance;
        //model_internal::_layer_b_dimensionsValidator.property = "layer_b_dimensions";
        model_internal::_layer_c_dimensionsValidator = new StyleValidator(model_internal::_instance.model_internal::_doValidationForLayer_c_dimensions);
        model_internal::_layer_c_dimensionsValidator.required = true;
        model_internal::_layer_c_dimensionsValidator.requiredFieldError = "layer_c_dimensions is required";
        //model_internal::_layer_c_dimensionsValidator.source = model_internal::_instance;
        //model_internal::_layer_c_dimensionsValidator.property = "layer_c_dimensions";
        model_internal::_layer_b_namesValidator = new StyleValidator(model_internal::_instance.model_internal::_doValidationForLayer_b_names);
        model_internal::_layer_b_namesValidator.required = true;
        model_internal::_layer_b_namesValidator.requiredFieldError = "layer_b_names is required";
        //model_internal::_layer_b_namesValidator.source = model_internal::_instance;
        //model_internal::_layer_b_namesValidator.property = "layer_b_names";
        model_internal::_int_id_summaryValidator = new StyleValidator(model_internal::_instance.model_internal::_doValidationForInt_id_summary);
        model_internal::_int_id_summaryValidator.required = true;
        model_internal::_int_id_summaryValidator.requiredFieldError = "int_id_summary is required";
        //model_internal::_int_id_summaryValidator.source = model_internal::_instance;
        //model_internal::_int_id_summaryValidator.property = "int_id_summary";
        model_internal::_systemValidator = new StyleValidator(model_internal::_instance.model_internal::_doValidationForSystem);
        model_internal::_systemValidator.required = true;
        model_internal::_systemValidator.requiredFieldError = "system is required";
        //model_internal::_systemValidator.source = model_internal::_instance;
        //model_internal::_systemValidator.property = "system";
        model_internal::_nameValidator = new StyleValidator(model_internal::_instance.model_internal::_doValidationForName);
        model_internal::_nameValidator.required = true;
        model_internal::_nameValidator.requiredFieldError = "name is required";
        //model_internal::_nameValidator.source = model_internal::_instance;
        //model_internal::_nameValidator.property = "name";
        model_internal::_layer_c_namesValidator = new StyleValidator(model_internal::_instance.model_internal::_doValidationForLayer_c_names);
        model_internal::_layer_c_namesValidator.required = true;
        model_internal::_layer_c_namesValidator.requiredFieldError = "layer_c_names is required";
        //model_internal::_layer_c_namesValidator.source = model_internal::_instance;
        //model_internal::_layer_c_namesValidator.property = "layer_c_names";
        model_internal::_layer_d_namesValidator = new StyleValidator(model_internal::_instance.model_internal::_doValidationForLayer_d_names);
        model_internal::_layer_d_namesValidator.required = true;
        model_internal::_layer_d_namesValidator.requiredFieldError = "layer_d_names is required";
        //model_internal::_layer_d_namesValidator.source = model_internal::_instance;
        //model_internal::_layer_d_namesValidator.property = "layer_d_names";
        model_internal::_layer_d_dimensionsValidator = new StyleValidator(model_internal::_instance.model_internal::_doValidationForLayer_d_dimensions);
        model_internal::_layer_d_dimensionsValidator.required = true;
        model_internal::_layer_d_dimensionsValidator.requiredFieldError = "layer_d_dimensions is required";
        //model_internal::_layer_d_dimensionsValidator.source = model_internal::_instance;
        //model_internal::_layer_d_dimensionsValidator.property = "layer_d_dimensions";
        model_internal::_layer_a_namesValidator = new StyleValidator(model_internal::_instance.model_internal::_doValidationForLayer_a_names);
        model_internal::_layer_a_namesValidator.required = true;
        model_internal::_layer_a_namesValidator.requiredFieldError = "layer_a_names is required";
        //model_internal::_layer_a_namesValidator.source = model_internal::_instance;
        //model_internal::_layer_a_namesValidator.property = "layer_a_names";
    }

    override public function getEntityName():String
    {
        return model_internal::entityName;
    }

    override public function getProperties():Array
    {
        return model_internal::allProperties;
    }

    override public function getAssociationProperties():Array
    {
        return model_internal::allAssociationProperties;
    }

    override public function getRequiredProperties():Array
    {
         return model_internal::allRequiredProperties;   
    }

    override public function getDataProperties():Array
    {
        return model_internal::dataProperties;
    }

    public function getSourceProperties():Array
    {
        return model_internal::sourceProperties;
    }

    public function getNonDerivedProperties():Array
    {
        return model_internal::nonDerivedProperties;
    }

    override public function getGuardedProperties():Array
    {
        return model_internal::guardedProperties;
    }

    override public function getUnguardedProperties():Array
    {
        return model_internal::allAlwaysAvailableProperties;
    }

    override public function getDependants(propertyName:String):Array
    {
       if (model_internal::nonDerivedProperties.indexOf(propertyName) == -1)
            throw new Error(propertyName + " is not a data property of entity Constructions");
            
       return model_internal::dependentsOnMap[propertyName] as Array;  
    }

    override public function getDependedOnServices():Array
    {
        return model_internal::dependedOnServices;
    }

    override public function getCollectionProperties():Array
    {
        return model_internal::collectionProperties;
    }

    override public function getCollectionBase(propertyName:String):String
    {
        if (model_internal::collectionProperties.indexOf(propertyName) == -1)
            throw new Error(propertyName + " is not a collection property of entity Constructions");

        return model_internal::collectionBaseMap[propertyName];
    }
    
    override public function getPropertyType(propertyName:String):String
    {
        if (model_internal::allProperties.indexOf(propertyName) == -1)
            throw new Error(propertyName + " is not a property of Constructions");

        return model_internal::propertyTypeMap[propertyName];
    }

    override public function getAvailableProperties():com.adobe.fiber.valueobjects.IPropertyIterator
    {
        return new com.adobe.fiber.valueobjects.AvailablePropertyIterator(this);
    }

    override public function getValue(propertyName:String):*
    {
        if (model_internal::allProperties.indexOf(propertyName) == -1)
        {
            throw new Error(propertyName + " does not exist for entity Constructions");
        }

        return model_internal::_instance[propertyName];
    }

    override public function setValue(propertyName:String, value:*):void
    {
        if (model_internal::nonDerivedProperties.indexOf(propertyName) == -1)
        {
            throw new Error(propertyName + " is not a modifiable property of entity Constructions");
        }

        model_internal::_instance[propertyName] = value;
    }

    override public function getMappedByProperty(associationProperty:String):String
    {
        switch(associationProperty)
        {
            default:
            {
                return null;
            }
        }
    }

    override public function getPropertyLength(propertyName:String):int
    {
        switch(propertyName)
        {
            default:
            {
                return 0;
            }
        }
    }

    override public function isAvailable(propertyName:String):Boolean
    {
        if (model_internal::allProperties.indexOf(propertyName) == -1)
        {
            throw new Error(propertyName + " does not exist for entity Constructions");
        }

        if (model_internal::allAlwaysAvailableProperties.indexOf(propertyName) != -1)
        {
            return true;
        }

        switch(propertyName)
        {
            default:
            {
                return true;
            }
        }
    }

    override public function getIdentityMap():Object
    {
        var returnMap:Object = new Object();
        returnMap["constr_id"] = model_internal::_instance.constr_id;

        return returnMap;
    }

    [Bindable(event="propertyChange")]
    override public function get invalidConstraints():Array
    {
        if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
        {
            return model_internal::_instance.model_internal::_invalidConstraints;
        }
        else
        {
            // recalculate isValid
            model_internal::_instance.model_internal::_isValid = model_internal::_instance.model_internal::calculateIsValid();
            return model_internal::_instance.model_internal::_invalidConstraints;        
        }
    }

    [Bindable(event="propertyChange")]
    override public function get validationFailureMessages():Array
    {
        if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
        {
            return model_internal::_instance.model_internal::_validationFailureMessages;
        }
        else
        {
            // recalculate isValid
            model_internal::_instance.model_internal::_isValid = model_internal::_instance.model_internal::calculateIsValid();
            return model_internal::_instance.model_internal::_validationFailureMessages;
        }
    }

    override public function getDependantInvalidConstraints(propertyName:String):Array
    {
        var dependants:Array = getDependants(propertyName);
        if (dependants.length == 0)
        {
            return emptyArray;
        }

        var currentlyInvalid:Array = invalidConstraints;
        if (currentlyInvalid.length == 0)
        {
            return emptyArray;
        }

        var filterFunc:Function = function(element:*, index:int, arr:Array):Boolean
        {
            return dependants.indexOf(element) > -1;
        }

        return currentlyInvalid.filter(filterFunc);
    }

    /**
     * isValid
     */
    [Bindable(event="propertyChange")] 
    public function get isValid() : Boolean
    {
        if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
        {
            return model_internal::_instance.model_internal::_isValid;
        }
        else
        {
            // recalculate isValid
            model_internal::_instance.model_internal::_isValid = model_internal::_instance.model_internal::calculateIsValid();
            return model_internal::_instance.model_internal::_isValid;
        }
    }

    [Bindable(event="propertyChange")]
    public function get isPartnerFSAvailable():Boolean
    {
        return true;
    }

    [Bindable(event="propertyChange")]
    public function get isUserFSAvailable():Boolean
    {
        return true;
    }

    [Bindable(event="propertyChange")]
    public function get isPublishedAvailable():Boolean
    {
        return true;
    }

    [Bindable(event="propertyChange")]
    public function get isInt_id_climateAvailable():Boolean
    {
        return true;
    }

    [Bindable(event="propertyChange")]
    public function get isInt_id_kindAvailable():Boolean
    {
        return true;
    }

    [Bindable(event="propertyChange")]
    public function get isInt_id_staticAvailable():Boolean
    {
        return true;
    }

    [Bindable(event="propertyChange")]
    public function get isInt_id_facadeAvailable():Boolean
    {
        return true;
    }

    [Bindable(event="propertyChange")]
    public function get isInt_id_constructionAvailable():Boolean
    {
        return true;
    }

    [Bindable(event="propertyChange")]
    public function get isInt_id_jointAvailable():Boolean
    {
        return true;
    }

    [Bindable(event="propertyChange")]
    public function get isInt_id_noAvailable():Boolean
    {
        return true;
    }

    [Bindable(event="propertyChange")]
    public function get isInt_id_localisationAvailable():Boolean
    {
        return true;
    }

    [Bindable(event="propertyChange")]
    public function get isVersion_nrAvailable():Boolean
    {
        return true;
    }

    [Bindable(event="propertyChange")]
    public function get isValid_sinceAvailable():Boolean
    {
        return true;
    }

    [Bindable(event="propertyChange")]
    public function get isValid_toAvailable():Boolean
    {
        return true;
    }

    [Bindable(event="propertyChange")]
    public function get isImageAvailable():Boolean
    {
        return true;
    }

    [Bindable(event="propertyChange")]
    public function get isImage_captionAvailable():Boolean
    {
        return true;
    }

    [Bindable(event="propertyChange")]
    public function get isUrl_dxfAvailable():Boolean
    {
        return true;
    }

    [Bindable(event="propertyChange")]
    public function get isUrl_dwgAvailable():Boolean
    {
        return true;
    }

    [Bindable(event="propertyChange")]
    public function get isUrl_plaAvailable():Boolean
    {
        return true;
    }

    [Bindable(event="propertyChange")]
    public function get isUrl_pdfAvailable():Boolean
    {
        return true;
    }

    [Bindable(event="propertyChange")]
    public function get isUrl_jpgAvailable():Boolean
    {
        return true;
    }

    [Bindable(event="propertyChange")]
    public function get isRwAvailable():Boolean
    {
        return true;
    }

    [Bindable(event="propertyChange")]
    public function get isLntwAvailable():Boolean
    {
        return true;
    }

    [Bindable(event="propertyChange")]
    public function get isReiAvailable():Boolean
    {
        return true;
    }

    [Bindable(event="propertyChange")]
    public function get isNotesAvailable():Boolean
    {
        return true;
    }

    [Bindable(event="propertyChange")]
    public function get isPhysicsAvailable():Boolean
    {
        return true;
    }

    [Bindable(event="propertyChange")]
    public function get isAdd_notesAvailable():Boolean
    {
        return true;
    }

    [Bindable(event="propertyChange")]
    public function get isRel_infoAvailable():Boolean
    {
        return true;
    }

    [Bindable(event="propertyChange")]
    public function get isLayer_a_dimensionsAvailable():Boolean
    {
        return true;
    }

    [Bindable(event="propertyChange")]
    public function get isLayer_b_dimensionsAvailable():Boolean
    {
        return true;
    }

    [Bindable(event="propertyChange")]
    public function get isLayer_c_dimensionsAvailable():Boolean
    {
        return true;
    }

    [Bindable(event="propertyChange")]
    public function get isConstr_idAvailable():Boolean
    {
        return true;
    }

    [Bindable(event="propertyChange")]
    public function get isU_value_aAvailable():Boolean
    {
        return true;
    }

    [Bindable(event="propertyChange")]
    public function get isU_value_bAvailable():Boolean
    {
        return true;
    }

    [Bindable(event="propertyChange")]
    public function get isLayer_b_namesAvailable():Boolean
    {
        return true;
    }

    [Bindable(event="propertyChange")]
    public function get isU_value_cAvailable():Boolean
    {
        return true;
    }

    [Bindable(event="propertyChange")]
    public function get isU_value_dAvailable():Boolean
    {
        return true;
    }

    [Bindable(event="propertyChange")]
    public function get isInt_id_summaryAvailable():Boolean
    {
        return true;
    }

    [Bindable(event="propertyChange")]
    public function get isSystemAvailable():Boolean
    {
        return true;
    }

    [Bindable(event="propertyChange")]
    public function get isNameAvailable():Boolean
    {
        return true;
    }

    [Bindable(event="propertyChange")]
    public function get isLayer_c_namesAvailable():Boolean
    {
        return true;
    }

    [Bindable(event="propertyChange")]
    public function get isActive_tabAvailable():Boolean
    {
        return true;
    }

    [Bindable(event="propertyChange")]
    public function get isLayer_d_namesAvailable():Boolean
    {
        return true;
    }

    [Bindable(event="propertyChange")]
    public function get isLayer_d_dimensionsAvailable():Boolean
    {
        return true;
    }

    [Bindable(event="propertyChange")]
    public function get isLayer_a_namesAvailable():Boolean
    {
        return true;
    }


    /**
     * derived property recalculation
     */
    public function invalidateDependentOnPartnerFS():void
    {
        if (model_internal::_partnerFSIsValidCacheInitialized )
        {
            model_internal::_instance.model_internal::_doValidationCacheOfPartnerFS = null;
            model_internal::calculatePartnerFSIsValid();
        }
    }
    public function invalidateDependentOnPublished():void
    {
        if (model_internal::_publishedIsValidCacheInitialized )
        {
            model_internal::_instance.model_internal::_doValidationCacheOfPublished = null;
            model_internal::calculatePublishedIsValid();
        }
    }
    public function invalidateDependentOnInt_id_climate():void
    {
        if (model_internal::_int_id_climateIsValidCacheInitialized )
        {
            model_internal::_instance.model_internal::_doValidationCacheOfInt_id_climate = null;
            model_internal::calculateInt_id_climateIsValid();
        }
    }
    public function invalidateDependentOnInt_id_kind():void
    {
        if (model_internal::_int_id_kindIsValidCacheInitialized )
        {
            model_internal::_instance.model_internal::_doValidationCacheOfInt_id_kind = null;
            model_internal::calculateInt_id_kindIsValid();
        }
    }
    public function invalidateDependentOnInt_id_static():void
    {
        if (model_internal::_int_id_staticIsValidCacheInitialized )
        {
            model_internal::_instance.model_internal::_doValidationCacheOfInt_id_static = null;
            model_internal::calculateInt_id_staticIsValid();
        }
    }
    public function invalidateDependentOnInt_id_facade():void
    {
        if (model_internal::_int_id_facadeIsValidCacheInitialized )
        {
            model_internal::_instance.model_internal::_doValidationCacheOfInt_id_facade = null;
            model_internal::calculateInt_id_facadeIsValid();
        }
    }
    public function invalidateDependentOnInt_id_joint():void
    {
        if (model_internal::_int_id_jointIsValidCacheInitialized )
        {
            model_internal::_instance.model_internal::_doValidationCacheOfInt_id_joint = null;
            model_internal::calculateInt_id_jointIsValid();
        }
    }
    public function invalidateDependentOnInt_id_no():void
    {
        if (model_internal::_int_id_noIsValidCacheInitialized )
        {
            model_internal::_instance.model_internal::_doValidationCacheOfInt_id_no = null;
            model_internal::calculateInt_id_noIsValid();
        }
    }
    public function invalidateDependentOnInt_id_localisation():void
    {
        if (model_internal::_int_id_localisationIsValidCacheInitialized )
        {
            model_internal::_instance.model_internal::_doValidationCacheOfInt_id_localisation = null;
            model_internal::calculateInt_id_localisationIsValid();
        }
    }
    public function invalidateDependentOnValid_since():void
    {
        if (model_internal::_valid_sinceIsValidCacheInitialized )
        {
            model_internal::_instance.model_internal::_doValidationCacheOfValid_since = null;
            model_internal::calculateValid_sinceIsValid();
        }
    }
    public function invalidateDependentOnValid_to():void
    {
        if (model_internal::_valid_toIsValidCacheInitialized )
        {
            model_internal::_instance.model_internal::_doValidationCacheOfValid_to = null;
            model_internal::calculateValid_toIsValid();
        }
    }
    public function invalidateDependentOnImage():void
    {
        if (model_internal::_imageIsValidCacheInitialized )
        {
            model_internal::_instance.model_internal::_doValidationCacheOfImage = null;
            model_internal::calculateImageIsValid();
        }
    }
    public function invalidateDependentOnImage_caption():void
    {
        if (model_internal::_image_captionIsValidCacheInitialized )
        {
            model_internal::_instance.model_internal::_doValidationCacheOfImage_caption = null;
            model_internal::calculateImage_captionIsValid();
        }
    }
    public function invalidateDependentOnUrl_dxf():void
    {
        if (model_internal::_url_dxfIsValidCacheInitialized )
        {
            model_internal::_instance.model_internal::_doValidationCacheOfUrl_dxf = null;
            model_internal::calculateUrl_dxfIsValid();
        }
    }
    public function invalidateDependentOnUrl_dwg():void
    {
        if (model_internal::_url_dwgIsValidCacheInitialized )
        {
            model_internal::_instance.model_internal::_doValidationCacheOfUrl_dwg = null;
            model_internal::calculateUrl_dwgIsValid();
        }
    }
    public function invalidateDependentOnUrl_pla():void
    {
        if (model_internal::_url_plaIsValidCacheInitialized )
        {
            model_internal::_instance.model_internal::_doValidationCacheOfUrl_pla = null;
            model_internal::calculateUrl_plaIsValid();
        }
    }
    public function invalidateDependentOnUrl_pdf():void
    {
        if (model_internal::_url_pdfIsValidCacheInitialized )
        {
            model_internal::_instance.model_internal::_doValidationCacheOfUrl_pdf = null;
            model_internal::calculateUrl_pdfIsValid();
        }
    }
    public function invalidateDependentOnUrl_jpg():void
    {
        if (model_internal::_url_jpgIsValidCacheInitialized )
        {
            model_internal::_instance.model_internal::_doValidationCacheOfUrl_jpg = null;
            model_internal::calculateUrl_jpgIsValid();
        }
    }
    public function invalidateDependentOnRw():void
    {
        if (model_internal::_rwIsValidCacheInitialized )
        {
            model_internal::_instance.model_internal::_doValidationCacheOfRw = null;
            model_internal::calculateRwIsValid();
        }
    }
    public function invalidateDependentOnLntw():void
    {
        if (model_internal::_lntwIsValidCacheInitialized )
        {
            model_internal::_instance.model_internal::_doValidationCacheOfLntw = null;
            model_internal::calculateLntwIsValid();
        }
    }
    public function invalidateDependentOnNotes():void
    {
        if (model_internal::_notesIsValidCacheInitialized )
        {
            model_internal::_instance.model_internal::_doValidationCacheOfNotes = null;
            model_internal::calculateNotesIsValid();
        }
    }
    public function invalidateDependentOnPhysics():void
    {
        if (model_internal::_physicsIsValidCacheInitialized )
        {
            model_internal::_instance.model_internal::_doValidationCacheOfPhysics = null;
            model_internal::calculatePhysicsIsValid();
        }
    }
    public function invalidateDependentOnAdd_notes():void
    {
        if (model_internal::_add_notesIsValidCacheInitialized )
        {
            model_internal::_instance.model_internal::_doValidationCacheOfAdd_notes = null;
            model_internal::calculateAdd_notesIsValid();
        }
    }
    public function invalidateDependentOnRel_info():void
    {
        if (model_internal::_rel_infoIsValidCacheInitialized )
        {
            model_internal::_instance.model_internal::_doValidationCacheOfRel_info = null;
            model_internal::calculateRel_infoIsValid();
        }
    }
    public function invalidateDependentOnLayer_a_dimensions():void
    {
        if (model_internal::_layer_a_dimensionsIsValidCacheInitialized )
        {
            model_internal::_instance.model_internal::_doValidationCacheOfLayer_a_dimensions = null;
            model_internal::calculateLayer_a_dimensionsIsValid();
        }
    }
    public function invalidateDependentOnLayer_b_dimensions():void
    {
        if (model_internal::_layer_b_dimensionsIsValidCacheInitialized )
        {
            model_internal::_instance.model_internal::_doValidationCacheOfLayer_b_dimensions = null;
            model_internal::calculateLayer_b_dimensionsIsValid();
        }
    }
    public function invalidateDependentOnLayer_c_dimensions():void
    {
        if (model_internal::_layer_c_dimensionsIsValidCacheInitialized )
        {
            model_internal::_instance.model_internal::_doValidationCacheOfLayer_c_dimensions = null;
            model_internal::calculateLayer_c_dimensionsIsValid();
        }
    }
    public function invalidateDependentOnLayer_b_names():void
    {
        if (model_internal::_layer_b_namesIsValidCacheInitialized )
        {
            model_internal::_instance.model_internal::_doValidationCacheOfLayer_b_names = null;
            model_internal::calculateLayer_b_namesIsValid();
        }
    }
    public function invalidateDependentOnInt_id_summary():void
    {
        if (model_internal::_int_id_summaryIsValidCacheInitialized )
        {
            model_internal::_instance.model_internal::_doValidationCacheOfInt_id_summary = null;
            model_internal::calculateInt_id_summaryIsValid();
        }
    }
    public function invalidateDependentOnSystem():void
    {
        if (model_internal::_systemIsValidCacheInitialized )
        {
            model_internal::_instance.model_internal::_doValidationCacheOfSystem = null;
            model_internal::calculateSystemIsValid();
        }
    }
    public function invalidateDependentOnName():void
    {
        if (model_internal::_nameIsValidCacheInitialized )
        {
            model_internal::_instance.model_internal::_doValidationCacheOfName = null;
            model_internal::calculateNameIsValid();
        }
    }
    public function invalidateDependentOnLayer_c_names():void
    {
        if (model_internal::_layer_c_namesIsValidCacheInitialized )
        {
            model_internal::_instance.model_internal::_doValidationCacheOfLayer_c_names = null;
            model_internal::calculateLayer_c_namesIsValid();
        }
    }
    public function invalidateDependentOnLayer_d_names():void
    {
        if (model_internal::_layer_d_namesIsValidCacheInitialized )
        {
            model_internal::_instance.model_internal::_doValidationCacheOfLayer_d_names = null;
            model_internal::calculateLayer_d_namesIsValid();
        }
    }
    public function invalidateDependentOnLayer_d_dimensions():void
    {
        if (model_internal::_layer_d_dimensionsIsValidCacheInitialized )
        {
            model_internal::_instance.model_internal::_doValidationCacheOfLayer_d_dimensions = null;
            model_internal::calculateLayer_d_dimensionsIsValid();
        }
    }
    public function invalidateDependentOnLayer_a_names():void
    {
        if (model_internal::_layer_a_namesIsValidCacheInitialized )
        {
            model_internal::_instance.model_internal::_doValidationCacheOfLayer_a_names = null;
            model_internal::calculateLayer_a_namesIsValid();
        }
    }

    model_internal function fireChangeEvent(propertyName:String, oldValue:Object, newValue:Object):void
    {
        this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, propertyName, oldValue, newValue));
    }

    [Bindable(event="propertyChange")]   
    public function get partnerFSStyle():com.adobe.fiber.styles.Style
    {
        return model_internal::_nullStyle;
    }

    public function get partnerFSValidator() : StyleValidator
    {
        return model_internal::_partnerFSValidator;
    }

    model_internal function set _partnerFSIsValid_der(value:Boolean):void 
    {
        var oldValue:Boolean = model_internal::_partnerFSIsValid;         
        if (oldValue !== value)
        {
            model_internal::_partnerFSIsValid = value;
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "partnerFSIsValid", oldValue, value));
        }                             
    }

    [Bindable(event="propertyChange")]
    public function get partnerFSIsValid():Boolean
    {
        if (!model_internal::_partnerFSIsValidCacheInitialized)
        {
            model_internal::calculatePartnerFSIsValid();
        }

        return model_internal::_partnerFSIsValid;
    }

    model_internal function calculatePartnerFSIsValid():void
    {
        var valRes:ValidationResultEvent = model_internal::_partnerFSValidator.validate(model_internal::_instance.partnerFS)
        model_internal::_partnerFSIsValid_der = (valRes.results == null);
        model_internal::_partnerFSIsValidCacheInitialized = true;
        if (valRes.results == null)
             model_internal::partnerFSValidationFailureMessages_der = emptyArray;
        else
        {
            var _valFailures:Array = new Array();
            for (var a:int = 0 ; a<valRes.results.length ; a++)
            {
                _valFailures.push(valRes.results[a].errorMessage);
            }
            model_internal::partnerFSValidationFailureMessages_der = _valFailures;
        }
    }

    [Bindable(event="propertyChange")]
    public function get partnerFSValidationFailureMessages():Array
    {
        if (model_internal::_partnerFSValidationFailureMessages == null)
            model_internal::calculatePartnerFSIsValid();

        return _partnerFSValidationFailureMessages;
    }

    model_internal function set partnerFSValidationFailureMessages_der(value:Array) : void
    {
        var oldValue:Array = model_internal::_partnerFSValidationFailureMessages;

        var needUpdate : Boolean = false;
        if (oldValue == null)
            needUpdate = true;
    
        // avoid firing the event when old and new value are different empty arrays
        if (!needUpdate && (oldValue !== value && (oldValue.length > 0 || value.length > 0)))
        {
            if (oldValue.length == value.length)
            {
                for (var a:int=0; a < oldValue.length; a++)
                {
                    if (oldValue[a] !== value[a])
                    {
                        needUpdate = true;
                        break;
                    }
                }
            }
            else
            {
                needUpdate = true;
            }
        }

        if (needUpdate)
        {
            model_internal::_partnerFSValidationFailureMessages = value;   
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "partnerFSValidationFailureMessages", oldValue, value));
            // Only execute calculateIsValid if it has been called before, to update the validationFailureMessages for
            // the entire entity.
            if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
            {
                model_internal::_instance.model_internal::isValid_der = model_internal::_instance.model_internal::calculateIsValid();
            }
        }
    }

    [Bindable(event="propertyChange")]   
    public function get userFSStyle():com.adobe.fiber.styles.Style
    {
        return model_internal::_nullStyle;
    }

    [Bindable(event="propertyChange")]   
    public function get publishedStyle():com.adobe.fiber.styles.Style
    {
        return model_internal::_nullStyle;
    }

    public function get publishedValidator() : StyleValidator
    {
        return model_internal::_publishedValidator;
    }

    model_internal function set _publishedIsValid_der(value:Boolean):void 
    {
        var oldValue:Boolean = model_internal::_publishedIsValid;         
        if (oldValue !== value)
        {
            model_internal::_publishedIsValid = value;
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "publishedIsValid", oldValue, value));
        }                             
    }

    [Bindable(event="propertyChange")]
    public function get publishedIsValid():Boolean
    {
        if (!model_internal::_publishedIsValidCacheInitialized)
        {
            model_internal::calculatePublishedIsValid();
        }

        return model_internal::_publishedIsValid;
    }

    model_internal function calculatePublishedIsValid():void
    {
        var valRes:ValidationResultEvent = model_internal::_publishedValidator.validate(model_internal::_instance.published)
        model_internal::_publishedIsValid_der = (valRes.results == null);
        model_internal::_publishedIsValidCacheInitialized = true;
        if (valRes.results == null)
             model_internal::publishedValidationFailureMessages_der = emptyArray;
        else
        {
            var _valFailures:Array = new Array();
            for (var a:int = 0 ; a<valRes.results.length ; a++)
            {
                _valFailures.push(valRes.results[a].errorMessage);
            }
            model_internal::publishedValidationFailureMessages_der = _valFailures;
        }
    }

    [Bindable(event="propertyChange")]
    public function get publishedValidationFailureMessages():Array
    {
        if (model_internal::_publishedValidationFailureMessages == null)
            model_internal::calculatePublishedIsValid();

        return _publishedValidationFailureMessages;
    }

    model_internal function set publishedValidationFailureMessages_der(value:Array) : void
    {
        var oldValue:Array = model_internal::_publishedValidationFailureMessages;

        var needUpdate : Boolean = false;
        if (oldValue == null)
            needUpdate = true;
    
        // avoid firing the event when old and new value are different empty arrays
        if (!needUpdate && (oldValue !== value && (oldValue.length > 0 || value.length > 0)))
        {
            if (oldValue.length == value.length)
            {
                for (var a:int=0; a < oldValue.length; a++)
                {
                    if (oldValue[a] !== value[a])
                    {
                        needUpdate = true;
                        break;
                    }
                }
            }
            else
            {
                needUpdate = true;
            }
        }

        if (needUpdate)
        {
            model_internal::_publishedValidationFailureMessages = value;   
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "publishedValidationFailureMessages", oldValue, value));
            // Only execute calculateIsValid if it has been called before, to update the validationFailureMessages for
            // the entire entity.
            if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
            {
                model_internal::_instance.model_internal::isValid_der = model_internal::_instance.model_internal::calculateIsValid();
            }
        }
    }

    [Bindable(event="propertyChange")]   
    public function get int_id_climateStyle():com.adobe.fiber.styles.Style
    {
        return model_internal::_nullStyle;
    }

    public function get int_id_climateValidator() : StyleValidator
    {
        return model_internal::_int_id_climateValidator;
    }

    model_internal function set _int_id_climateIsValid_der(value:Boolean):void 
    {
        var oldValue:Boolean = model_internal::_int_id_climateIsValid;         
        if (oldValue !== value)
        {
            model_internal::_int_id_climateIsValid = value;
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "int_id_climateIsValid", oldValue, value));
        }                             
    }

    [Bindable(event="propertyChange")]
    public function get int_id_climateIsValid():Boolean
    {
        if (!model_internal::_int_id_climateIsValidCacheInitialized)
        {
            model_internal::calculateInt_id_climateIsValid();
        }

        return model_internal::_int_id_climateIsValid;
    }

    model_internal function calculateInt_id_climateIsValid():void
    {
        var valRes:ValidationResultEvent = model_internal::_int_id_climateValidator.validate(model_internal::_instance.int_id_climate)
        model_internal::_int_id_climateIsValid_der = (valRes.results == null);
        model_internal::_int_id_climateIsValidCacheInitialized = true;
        if (valRes.results == null)
             model_internal::int_id_climateValidationFailureMessages_der = emptyArray;
        else
        {
            var _valFailures:Array = new Array();
            for (var a:int = 0 ; a<valRes.results.length ; a++)
            {
                _valFailures.push(valRes.results[a].errorMessage);
            }
            model_internal::int_id_climateValidationFailureMessages_der = _valFailures;
        }
    }

    [Bindable(event="propertyChange")]
    public function get int_id_climateValidationFailureMessages():Array
    {
        if (model_internal::_int_id_climateValidationFailureMessages == null)
            model_internal::calculateInt_id_climateIsValid();

        return _int_id_climateValidationFailureMessages;
    }

    model_internal function set int_id_climateValidationFailureMessages_der(value:Array) : void
    {
        var oldValue:Array = model_internal::_int_id_climateValidationFailureMessages;

        var needUpdate : Boolean = false;
        if (oldValue == null)
            needUpdate = true;
    
        // avoid firing the event when old and new value are different empty arrays
        if (!needUpdate && (oldValue !== value && (oldValue.length > 0 || value.length > 0)))
        {
            if (oldValue.length == value.length)
            {
                for (var a:int=0; a < oldValue.length; a++)
                {
                    if (oldValue[a] !== value[a])
                    {
                        needUpdate = true;
                        break;
                    }
                }
            }
            else
            {
                needUpdate = true;
            }
        }

        if (needUpdate)
        {
            model_internal::_int_id_climateValidationFailureMessages = value;   
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "int_id_climateValidationFailureMessages", oldValue, value));
            // Only execute calculateIsValid if it has been called before, to update the validationFailureMessages for
            // the entire entity.
            if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
            {
                model_internal::_instance.model_internal::isValid_der = model_internal::_instance.model_internal::calculateIsValid();
            }
        }
    }

    [Bindable(event="propertyChange")]   
    public function get int_id_kindStyle():com.adobe.fiber.styles.Style
    {
        return model_internal::_nullStyle;
    }

    public function get int_id_kindValidator() : StyleValidator
    {
        return model_internal::_int_id_kindValidator;
    }

    model_internal function set _int_id_kindIsValid_der(value:Boolean):void 
    {
        var oldValue:Boolean = model_internal::_int_id_kindIsValid;         
        if (oldValue !== value)
        {
            model_internal::_int_id_kindIsValid = value;
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "int_id_kindIsValid", oldValue, value));
        }                             
    }

    [Bindable(event="propertyChange")]
    public function get int_id_kindIsValid():Boolean
    {
        if (!model_internal::_int_id_kindIsValidCacheInitialized)
        {
            model_internal::calculateInt_id_kindIsValid();
        }

        return model_internal::_int_id_kindIsValid;
    }

    model_internal function calculateInt_id_kindIsValid():void
    {
        var valRes:ValidationResultEvent = model_internal::_int_id_kindValidator.validate(model_internal::_instance.int_id_kind)
        model_internal::_int_id_kindIsValid_der = (valRes.results == null);
        model_internal::_int_id_kindIsValidCacheInitialized = true;
        if (valRes.results == null)
             model_internal::int_id_kindValidationFailureMessages_der = emptyArray;
        else
        {
            var _valFailures:Array = new Array();
            for (var a:int = 0 ; a<valRes.results.length ; a++)
            {
                _valFailures.push(valRes.results[a].errorMessage);
            }
            model_internal::int_id_kindValidationFailureMessages_der = _valFailures;
        }
    }

    [Bindable(event="propertyChange")]
    public function get int_id_kindValidationFailureMessages():Array
    {
        if (model_internal::_int_id_kindValidationFailureMessages == null)
            model_internal::calculateInt_id_kindIsValid();

        return _int_id_kindValidationFailureMessages;
    }

    model_internal function set int_id_kindValidationFailureMessages_der(value:Array) : void
    {
        var oldValue:Array = model_internal::_int_id_kindValidationFailureMessages;

        var needUpdate : Boolean = false;
        if (oldValue == null)
            needUpdate = true;
    
        // avoid firing the event when old and new value are different empty arrays
        if (!needUpdate && (oldValue !== value && (oldValue.length > 0 || value.length > 0)))
        {
            if (oldValue.length == value.length)
            {
                for (var a:int=0; a < oldValue.length; a++)
                {
                    if (oldValue[a] !== value[a])
                    {
                        needUpdate = true;
                        break;
                    }
                }
            }
            else
            {
                needUpdate = true;
            }
        }

        if (needUpdate)
        {
            model_internal::_int_id_kindValidationFailureMessages = value;   
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "int_id_kindValidationFailureMessages", oldValue, value));
            // Only execute calculateIsValid if it has been called before, to update the validationFailureMessages for
            // the entire entity.
            if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
            {
                model_internal::_instance.model_internal::isValid_der = model_internal::_instance.model_internal::calculateIsValid();
            }
        }
    }

    [Bindable(event="propertyChange")]   
    public function get int_id_staticStyle():com.adobe.fiber.styles.Style
    {
        return model_internal::_nullStyle;
    }

    public function get int_id_staticValidator() : StyleValidator
    {
        return model_internal::_int_id_staticValidator;
    }

    model_internal function set _int_id_staticIsValid_der(value:Boolean):void 
    {
        var oldValue:Boolean = model_internal::_int_id_staticIsValid;         
        if (oldValue !== value)
        {
            model_internal::_int_id_staticIsValid = value;
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "int_id_staticIsValid", oldValue, value));
        }                             
    }

    [Bindable(event="propertyChange")]
    public function get int_id_staticIsValid():Boolean
    {
        if (!model_internal::_int_id_staticIsValidCacheInitialized)
        {
            model_internal::calculateInt_id_staticIsValid();
        }

        return model_internal::_int_id_staticIsValid;
    }

    model_internal function calculateInt_id_staticIsValid():void
    {
        var valRes:ValidationResultEvent = model_internal::_int_id_staticValidator.validate(model_internal::_instance.int_id_static)
        model_internal::_int_id_staticIsValid_der = (valRes.results == null);
        model_internal::_int_id_staticIsValidCacheInitialized = true;
        if (valRes.results == null)
             model_internal::int_id_staticValidationFailureMessages_der = emptyArray;
        else
        {
            var _valFailures:Array = new Array();
            for (var a:int = 0 ; a<valRes.results.length ; a++)
            {
                _valFailures.push(valRes.results[a].errorMessage);
            }
            model_internal::int_id_staticValidationFailureMessages_der = _valFailures;
        }
    }

    [Bindable(event="propertyChange")]
    public function get int_id_staticValidationFailureMessages():Array
    {
        if (model_internal::_int_id_staticValidationFailureMessages == null)
            model_internal::calculateInt_id_staticIsValid();

        return _int_id_staticValidationFailureMessages;
    }

    model_internal function set int_id_staticValidationFailureMessages_der(value:Array) : void
    {
        var oldValue:Array = model_internal::_int_id_staticValidationFailureMessages;

        var needUpdate : Boolean = false;
        if (oldValue == null)
            needUpdate = true;
    
        // avoid firing the event when old and new value are different empty arrays
        if (!needUpdate && (oldValue !== value && (oldValue.length > 0 || value.length > 0)))
        {
            if (oldValue.length == value.length)
            {
                for (var a:int=0; a < oldValue.length; a++)
                {
                    if (oldValue[a] !== value[a])
                    {
                        needUpdate = true;
                        break;
                    }
                }
            }
            else
            {
                needUpdate = true;
            }
        }

        if (needUpdate)
        {
            model_internal::_int_id_staticValidationFailureMessages = value;   
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "int_id_staticValidationFailureMessages", oldValue, value));
            // Only execute calculateIsValid if it has been called before, to update the validationFailureMessages for
            // the entire entity.
            if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
            {
                model_internal::_instance.model_internal::isValid_der = model_internal::_instance.model_internal::calculateIsValid();
            }
        }
    }

    [Bindable(event="propertyChange")]   
    public function get int_id_facadeStyle():com.adobe.fiber.styles.Style
    {
        return model_internal::_nullStyle;
    }

    public function get int_id_facadeValidator() : StyleValidator
    {
        return model_internal::_int_id_facadeValidator;
    }

    model_internal function set _int_id_facadeIsValid_der(value:Boolean):void 
    {
        var oldValue:Boolean = model_internal::_int_id_facadeIsValid;         
        if (oldValue !== value)
        {
            model_internal::_int_id_facadeIsValid = value;
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "int_id_facadeIsValid", oldValue, value));
        }                             
    }

    [Bindable(event="propertyChange")]
    public function get int_id_facadeIsValid():Boolean
    {
        if (!model_internal::_int_id_facadeIsValidCacheInitialized)
        {
            model_internal::calculateInt_id_facadeIsValid();
        }

        return model_internal::_int_id_facadeIsValid;
    }

    model_internal function calculateInt_id_facadeIsValid():void
    {
        var valRes:ValidationResultEvent = model_internal::_int_id_facadeValidator.validate(model_internal::_instance.int_id_facade)
        model_internal::_int_id_facadeIsValid_der = (valRes.results == null);
        model_internal::_int_id_facadeIsValidCacheInitialized = true;
        if (valRes.results == null)
             model_internal::int_id_facadeValidationFailureMessages_der = emptyArray;
        else
        {
            var _valFailures:Array = new Array();
            for (var a:int = 0 ; a<valRes.results.length ; a++)
            {
                _valFailures.push(valRes.results[a].errorMessage);
            }
            model_internal::int_id_facadeValidationFailureMessages_der = _valFailures;
        }
    }

    [Bindable(event="propertyChange")]
    public function get int_id_facadeValidationFailureMessages():Array
    {
        if (model_internal::_int_id_facadeValidationFailureMessages == null)
            model_internal::calculateInt_id_facadeIsValid();

        return _int_id_facadeValidationFailureMessages;
    }

    model_internal function set int_id_facadeValidationFailureMessages_der(value:Array) : void
    {
        var oldValue:Array = model_internal::_int_id_facadeValidationFailureMessages;

        var needUpdate : Boolean = false;
        if (oldValue == null)
            needUpdate = true;
    
        // avoid firing the event when old and new value are different empty arrays
        if (!needUpdate && (oldValue !== value && (oldValue.length > 0 || value.length > 0)))
        {
            if (oldValue.length == value.length)
            {
                for (var a:int=0; a < oldValue.length; a++)
                {
                    if (oldValue[a] !== value[a])
                    {
                        needUpdate = true;
                        break;
                    }
                }
            }
            else
            {
                needUpdate = true;
            }
        }

        if (needUpdate)
        {
            model_internal::_int_id_facadeValidationFailureMessages = value;   
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "int_id_facadeValidationFailureMessages", oldValue, value));
            // Only execute calculateIsValid if it has been called before, to update the validationFailureMessages for
            // the entire entity.
            if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
            {
                model_internal::_instance.model_internal::isValid_der = model_internal::_instance.model_internal::calculateIsValid();
            }
        }
    }

    [Bindable(event="propertyChange")]   
    public function get int_id_constructionStyle():com.adobe.fiber.styles.Style
    {
        return model_internal::_nullStyle;
    }

    [Bindable(event="propertyChange")]   
    public function get int_id_jointStyle():com.adobe.fiber.styles.Style
    {
        return model_internal::_nullStyle;
    }

    public function get int_id_jointValidator() : StyleValidator
    {
        return model_internal::_int_id_jointValidator;
    }

    model_internal function set _int_id_jointIsValid_der(value:Boolean):void 
    {
        var oldValue:Boolean = model_internal::_int_id_jointIsValid;         
        if (oldValue !== value)
        {
            model_internal::_int_id_jointIsValid = value;
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "int_id_jointIsValid", oldValue, value));
        }                             
    }

    [Bindable(event="propertyChange")]
    public function get int_id_jointIsValid():Boolean
    {
        if (!model_internal::_int_id_jointIsValidCacheInitialized)
        {
            model_internal::calculateInt_id_jointIsValid();
        }

        return model_internal::_int_id_jointIsValid;
    }

    model_internal function calculateInt_id_jointIsValid():void
    {
        var valRes:ValidationResultEvent = model_internal::_int_id_jointValidator.validate(model_internal::_instance.int_id_joint)
        model_internal::_int_id_jointIsValid_der = (valRes.results == null);
        model_internal::_int_id_jointIsValidCacheInitialized = true;
        if (valRes.results == null)
             model_internal::int_id_jointValidationFailureMessages_der = emptyArray;
        else
        {
            var _valFailures:Array = new Array();
            for (var a:int = 0 ; a<valRes.results.length ; a++)
            {
                _valFailures.push(valRes.results[a].errorMessage);
            }
            model_internal::int_id_jointValidationFailureMessages_der = _valFailures;
        }
    }

    [Bindable(event="propertyChange")]
    public function get int_id_jointValidationFailureMessages():Array
    {
        if (model_internal::_int_id_jointValidationFailureMessages == null)
            model_internal::calculateInt_id_jointIsValid();

        return _int_id_jointValidationFailureMessages;
    }

    model_internal function set int_id_jointValidationFailureMessages_der(value:Array) : void
    {
        var oldValue:Array = model_internal::_int_id_jointValidationFailureMessages;

        var needUpdate : Boolean = false;
        if (oldValue == null)
            needUpdate = true;
    
        // avoid firing the event when old and new value are different empty arrays
        if (!needUpdate && (oldValue !== value && (oldValue.length > 0 || value.length > 0)))
        {
            if (oldValue.length == value.length)
            {
                for (var a:int=0; a < oldValue.length; a++)
                {
                    if (oldValue[a] !== value[a])
                    {
                        needUpdate = true;
                        break;
                    }
                }
            }
            else
            {
                needUpdate = true;
            }
        }

        if (needUpdate)
        {
            model_internal::_int_id_jointValidationFailureMessages = value;   
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "int_id_jointValidationFailureMessages", oldValue, value));
            // Only execute calculateIsValid if it has been called before, to update the validationFailureMessages for
            // the entire entity.
            if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
            {
                model_internal::_instance.model_internal::isValid_der = model_internal::_instance.model_internal::calculateIsValid();
            }
        }
    }

    [Bindable(event="propertyChange")]   
    public function get int_id_noStyle():com.adobe.fiber.styles.Style
    {
        return model_internal::_nullStyle;
    }

    public function get int_id_noValidator() : StyleValidator
    {
        return model_internal::_int_id_noValidator;
    }

    model_internal function set _int_id_noIsValid_der(value:Boolean):void 
    {
        var oldValue:Boolean = model_internal::_int_id_noIsValid;         
        if (oldValue !== value)
        {
            model_internal::_int_id_noIsValid = value;
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "int_id_noIsValid", oldValue, value));
        }                             
    }

    [Bindable(event="propertyChange")]
    public function get int_id_noIsValid():Boolean
    {
        if (!model_internal::_int_id_noIsValidCacheInitialized)
        {
            model_internal::calculateInt_id_noIsValid();
        }

        return model_internal::_int_id_noIsValid;
    }

    model_internal function calculateInt_id_noIsValid():void
    {
        var valRes:ValidationResultEvent = model_internal::_int_id_noValidator.validate(model_internal::_instance.int_id_no)
        model_internal::_int_id_noIsValid_der = (valRes.results == null);
        model_internal::_int_id_noIsValidCacheInitialized = true;
        if (valRes.results == null)
             model_internal::int_id_noValidationFailureMessages_der = emptyArray;
        else
        {
            var _valFailures:Array = new Array();
            for (var a:int = 0 ; a<valRes.results.length ; a++)
            {
                _valFailures.push(valRes.results[a].errorMessage);
            }
            model_internal::int_id_noValidationFailureMessages_der = _valFailures;
        }
    }

    [Bindable(event="propertyChange")]
    public function get int_id_noValidationFailureMessages():Array
    {
        if (model_internal::_int_id_noValidationFailureMessages == null)
            model_internal::calculateInt_id_noIsValid();

        return _int_id_noValidationFailureMessages;
    }

    model_internal function set int_id_noValidationFailureMessages_der(value:Array) : void
    {
        var oldValue:Array = model_internal::_int_id_noValidationFailureMessages;

        var needUpdate : Boolean = false;
        if (oldValue == null)
            needUpdate = true;
    
        // avoid firing the event when old and new value are different empty arrays
        if (!needUpdate && (oldValue !== value && (oldValue.length > 0 || value.length > 0)))
        {
            if (oldValue.length == value.length)
            {
                for (var a:int=0; a < oldValue.length; a++)
                {
                    if (oldValue[a] !== value[a])
                    {
                        needUpdate = true;
                        break;
                    }
                }
            }
            else
            {
                needUpdate = true;
            }
        }

        if (needUpdate)
        {
            model_internal::_int_id_noValidationFailureMessages = value;   
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "int_id_noValidationFailureMessages", oldValue, value));
            // Only execute calculateIsValid if it has been called before, to update the validationFailureMessages for
            // the entire entity.
            if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
            {
                model_internal::_instance.model_internal::isValid_der = model_internal::_instance.model_internal::calculateIsValid();
            }
        }
    }

    [Bindable(event="propertyChange")]   
    public function get int_id_localisationStyle():com.adobe.fiber.styles.Style
    {
        return model_internal::_nullStyle;
    }

    public function get int_id_localisationValidator() : StyleValidator
    {
        return model_internal::_int_id_localisationValidator;
    }

    model_internal function set _int_id_localisationIsValid_der(value:Boolean):void 
    {
        var oldValue:Boolean = model_internal::_int_id_localisationIsValid;         
        if (oldValue !== value)
        {
            model_internal::_int_id_localisationIsValid = value;
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "int_id_localisationIsValid", oldValue, value));
        }                             
    }

    [Bindable(event="propertyChange")]
    public function get int_id_localisationIsValid():Boolean
    {
        if (!model_internal::_int_id_localisationIsValidCacheInitialized)
        {
            model_internal::calculateInt_id_localisationIsValid();
        }

        return model_internal::_int_id_localisationIsValid;
    }

    model_internal function calculateInt_id_localisationIsValid():void
    {
        var valRes:ValidationResultEvent = model_internal::_int_id_localisationValidator.validate(model_internal::_instance.int_id_localisation)
        model_internal::_int_id_localisationIsValid_der = (valRes.results == null);
        model_internal::_int_id_localisationIsValidCacheInitialized = true;
        if (valRes.results == null)
             model_internal::int_id_localisationValidationFailureMessages_der = emptyArray;
        else
        {
            var _valFailures:Array = new Array();
            for (var a:int = 0 ; a<valRes.results.length ; a++)
            {
                _valFailures.push(valRes.results[a].errorMessage);
            }
            model_internal::int_id_localisationValidationFailureMessages_der = _valFailures;
        }
    }

    [Bindable(event="propertyChange")]
    public function get int_id_localisationValidationFailureMessages():Array
    {
        if (model_internal::_int_id_localisationValidationFailureMessages == null)
            model_internal::calculateInt_id_localisationIsValid();

        return _int_id_localisationValidationFailureMessages;
    }

    model_internal function set int_id_localisationValidationFailureMessages_der(value:Array) : void
    {
        var oldValue:Array = model_internal::_int_id_localisationValidationFailureMessages;

        var needUpdate : Boolean = false;
        if (oldValue == null)
            needUpdate = true;
    
        // avoid firing the event when old and new value are different empty arrays
        if (!needUpdate && (oldValue !== value && (oldValue.length > 0 || value.length > 0)))
        {
            if (oldValue.length == value.length)
            {
                for (var a:int=0; a < oldValue.length; a++)
                {
                    if (oldValue[a] !== value[a])
                    {
                        needUpdate = true;
                        break;
                    }
                }
            }
            else
            {
                needUpdate = true;
            }
        }

        if (needUpdate)
        {
            model_internal::_int_id_localisationValidationFailureMessages = value;   
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "int_id_localisationValidationFailureMessages", oldValue, value));
            // Only execute calculateIsValid if it has been called before, to update the validationFailureMessages for
            // the entire entity.
            if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
            {
                model_internal::_instance.model_internal::isValid_der = model_internal::_instance.model_internal::calculateIsValid();
            }
        }
    }

    [Bindable(event="propertyChange")]   
    public function get version_nrStyle():com.adobe.fiber.styles.Style
    {
        return model_internal::_nullStyle;
    }

    [Bindable(event="propertyChange")]   
    public function get valid_sinceStyle():com.adobe.fiber.styles.Style
    {
        return model_internal::_nullStyle;
    }

    public function get valid_sinceValidator() : StyleValidator
    {
        return model_internal::_valid_sinceValidator;
    }

    model_internal function set _valid_sinceIsValid_der(value:Boolean):void 
    {
        var oldValue:Boolean = model_internal::_valid_sinceIsValid;         
        if (oldValue !== value)
        {
            model_internal::_valid_sinceIsValid = value;
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "valid_sinceIsValid", oldValue, value));
        }                             
    }

    [Bindable(event="propertyChange")]
    public function get valid_sinceIsValid():Boolean
    {
        if (!model_internal::_valid_sinceIsValidCacheInitialized)
        {
            model_internal::calculateValid_sinceIsValid();
        }

        return model_internal::_valid_sinceIsValid;
    }

    model_internal function calculateValid_sinceIsValid():void
    {
        var valRes:ValidationResultEvent = model_internal::_valid_sinceValidator.validate(model_internal::_instance.valid_since)
        model_internal::_valid_sinceIsValid_der = (valRes.results == null);
        model_internal::_valid_sinceIsValidCacheInitialized = true;
        if (valRes.results == null)
             model_internal::valid_sinceValidationFailureMessages_der = emptyArray;
        else
        {
            var _valFailures:Array = new Array();
            for (var a:int = 0 ; a<valRes.results.length ; a++)
            {
                _valFailures.push(valRes.results[a].errorMessage);
            }
            model_internal::valid_sinceValidationFailureMessages_der = _valFailures;
        }
    }

    [Bindable(event="propertyChange")]
    public function get valid_sinceValidationFailureMessages():Array
    {
        if (model_internal::_valid_sinceValidationFailureMessages == null)
            model_internal::calculateValid_sinceIsValid();

        return _valid_sinceValidationFailureMessages;
    }

    model_internal function set valid_sinceValidationFailureMessages_der(value:Array) : void
    {
        var oldValue:Array = model_internal::_valid_sinceValidationFailureMessages;

        var needUpdate : Boolean = false;
        if (oldValue == null)
            needUpdate = true;
    
        // avoid firing the event when old and new value are different empty arrays
        if (!needUpdate && (oldValue !== value && (oldValue.length > 0 || value.length > 0)))
        {
            if (oldValue.length == value.length)
            {
                for (var a:int=0; a < oldValue.length; a++)
                {
                    if (oldValue[a] !== value[a])
                    {
                        needUpdate = true;
                        break;
                    }
                }
            }
            else
            {
                needUpdate = true;
            }
        }

        if (needUpdate)
        {
            model_internal::_valid_sinceValidationFailureMessages = value;   
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "valid_sinceValidationFailureMessages", oldValue, value));
            // Only execute calculateIsValid if it has been called before, to update the validationFailureMessages for
            // the entire entity.
            if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
            {
                model_internal::_instance.model_internal::isValid_der = model_internal::_instance.model_internal::calculateIsValid();
            }
        }
    }

    [Bindable(event="propertyChange")]   
    public function get valid_toStyle():com.adobe.fiber.styles.Style
    {
        return model_internal::_nullStyle;
    }

    public function get valid_toValidator() : StyleValidator
    {
        return model_internal::_valid_toValidator;
    }

    model_internal function set _valid_toIsValid_der(value:Boolean):void 
    {
        var oldValue:Boolean = model_internal::_valid_toIsValid;         
        if (oldValue !== value)
        {
            model_internal::_valid_toIsValid = value;
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "valid_toIsValid", oldValue, value));
        }                             
    }

    [Bindable(event="propertyChange")]
    public function get valid_toIsValid():Boolean
    {
        if (!model_internal::_valid_toIsValidCacheInitialized)
        {
            model_internal::calculateValid_toIsValid();
        }

        return model_internal::_valid_toIsValid;
    }

    model_internal function calculateValid_toIsValid():void
    {
        var valRes:ValidationResultEvent = model_internal::_valid_toValidator.validate(model_internal::_instance.valid_to)
        model_internal::_valid_toIsValid_der = (valRes.results == null);
        model_internal::_valid_toIsValidCacheInitialized = true;
        if (valRes.results == null)
             model_internal::valid_toValidationFailureMessages_der = emptyArray;
        else
        {
            var _valFailures:Array = new Array();
            for (var a:int = 0 ; a<valRes.results.length ; a++)
            {
                _valFailures.push(valRes.results[a].errorMessage);
            }
            model_internal::valid_toValidationFailureMessages_der = _valFailures;
        }
    }

    [Bindable(event="propertyChange")]
    public function get valid_toValidationFailureMessages():Array
    {
        if (model_internal::_valid_toValidationFailureMessages == null)
            model_internal::calculateValid_toIsValid();

        return _valid_toValidationFailureMessages;
    }

    model_internal function set valid_toValidationFailureMessages_der(value:Array) : void
    {
        var oldValue:Array = model_internal::_valid_toValidationFailureMessages;

        var needUpdate : Boolean = false;
        if (oldValue == null)
            needUpdate = true;
    
        // avoid firing the event when old and new value are different empty arrays
        if (!needUpdate && (oldValue !== value && (oldValue.length > 0 || value.length > 0)))
        {
            if (oldValue.length == value.length)
            {
                for (var a:int=0; a < oldValue.length; a++)
                {
                    if (oldValue[a] !== value[a])
                    {
                        needUpdate = true;
                        break;
                    }
                }
            }
            else
            {
                needUpdate = true;
            }
        }

        if (needUpdate)
        {
            model_internal::_valid_toValidationFailureMessages = value;   
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "valid_toValidationFailureMessages", oldValue, value));
            // Only execute calculateIsValid if it has been called before, to update the validationFailureMessages for
            // the entire entity.
            if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
            {
                model_internal::_instance.model_internal::isValid_der = model_internal::_instance.model_internal::calculateIsValid();
            }
        }
    }

    [Bindable(event="propertyChange")]   
    public function get imageStyle():com.adobe.fiber.styles.Style
    {
        return model_internal::_nullStyle;
    }

    public function get imageValidator() : StyleValidator
    {
        return model_internal::_imageValidator;
    }

    model_internal function set _imageIsValid_der(value:Boolean):void 
    {
        var oldValue:Boolean = model_internal::_imageIsValid;         
        if (oldValue !== value)
        {
            model_internal::_imageIsValid = value;
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "imageIsValid", oldValue, value));
        }                             
    }

    [Bindable(event="propertyChange")]
    public function get imageIsValid():Boolean
    {
        if (!model_internal::_imageIsValidCacheInitialized)
        {
            model_internal::calculateImageIsValid();
        }

        return model_internal::_imageIsValid;
    }

    model_internal function calculateImageIsValid():void
    {
        var valRes:ValidationResultEvent = model_internal::_imageValidator.validate(model_internal::_instance.image)
        model_internal::_imageIsValid_der = (valRes.results == null);
        model_internal::_imageIsValidCacheInitialized = true;
        if (valRes.results == null)
             model_internal::imageValidationFailureMessages_der = emptyArray;
        else
        {
            var _valFailures:Array = new Array();
            for (var a:int = 0 ; a<valRes.results.length ; a++)
            {
                _valFailures.push(valRes.results[a].errorMessage);
            }
            model_internal::imageValidationFailureMessages_der = _valFailures;
        }
    }

    [Bindable(event="propertyChange")]
    public function get imageValidationFailureMessages():Array
    {
        if (model_internal::_imageValidationFailureMessages == null)
            model_internal::calculateImageIsValid();

        return _imageValidationFailureMessages;
    }

    model_internal function set imageValidationFailureMessages_der(value:Array) : void
    {
        var oldValue:Array = model_internal::_imageValidationFailureMessages;

        var needUpdate : Boolean = false;
        if (oldValue == null)
            needUpdate = true;
    
        // avoid firing the event when old and new value are different empty arrays
        if (!needUpdate && (oldValue !== value && (oldValue.length > 0 || value.length > 0)))
        {
            if (oldValue.length == value.length)
            {
                for (var a:int=0; a < oldValue.length; a++)
                {
                    if (oldValue[a] !== value[a])
                    {
                        needUpdate = true;
                        break;
                    }
                }
            }
            else
            {
                needUpdate = true;
            }
        }

        if (needUpdate)
        {
            model_internal::_imageValidationFailureMessages = value;   
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "imageValidationFailureMessages", oldValue, value));
            // Only execute calculateIsValid if it has been called before, to update the validationFailureMessages for
            // the entire entity.
            if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
            {
                model_internal::_instance.model_internal::isValid_der = model_internal::_instance.model_internal::calculateIsValid();
            }
        }
    }

    [Bindable(event="propertyChange")]   
    public function get image_captionStyle():com.adobe.fiber.styles.Style
    {
        return model_internal::_nullStyle;
    }

    public function get image_captionValidator() : StyleValidator
    {
        return model_internal::_image_captionValidator;
    }

    model_internal function set _image_captionIsValid_der(value:Boolean):void 
    {
        var oldValue:Boolean = model_internal::_image_captionIsValid;         
        if (oldValue !== value)
        {
            model_internal::_image_captionIsValid = value;
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "image_captionIsValid", oldValue, value));
        }                             
    }

    [Bindable(event="propertyChange")]
    public function get image_captionIsValid():Boolean
    {
        if (!model_internal::_image_captionIsValidCacheInitialized)
        {
            model_internal::calculateImage_captionIsValid();
        }

        return model_internal::_image_captionIsValid;
    }

    model_internal function calculateImage_captionIsValid():void
    {
        var valRes:ValidationResultEvent = model_internal::_image_captionValidator.validate(model_internal::_instance.image_caption)
        model_internal::_image_captionIsValid_der = (valRes.results == null);
        model_internal::_image_captionIsValidCacheInitialized = true;
        if (valRes.results == null)
             model_internal::image_captionValidationFailureMessages_der = emptyArray;
        else
        {
            var _valFailures:Array = new Array();
            for (var a:int = 0 ; a<valRes.results.length ; a++)
            {
                _valFailures.push(valRes.results[a].errorMessage);
            }
            model_internal::image_captionValidationFailureMessages_der = _valFailures;
        }
    }

    [Bindable(event="propertyChange")]
    public function get image_captionValidationFailureMessages():Array
    {
        if (model_internal::_image_captionValidationFailureMessages == null)
            model_internal::calculateImage_captionIsValid();

        return _image_captionValidationFailureMessages;
    }

    model_internal function set image_captionValidationFailureMessages_der(value:Array) : void
    {
        var oldValue:Array = model_internal::_image_captionValidationFailureMessages;

        var needUpdate : Boolean = false;
        if (oldValue == null)
            needUpdate = true;
    
        // avoid firing the event when old and new value are different empty arrays
        if (!needUpdate && (oldValue !== value && (oldValue.length > 0 || value.length > 0)))
        {
            if (oldValue.length == value.length)
            {
                for (var a:int=0; a < oldValue.length; a++)
                {
                    if (oldValue[a] !== value[a])
                    {
                        needUpdate = true;
                        break;
                    }
                }
            }
            else
            {
                needUpdate = true;
            }
        }

        if (needUpdate)
        {
            model_internal::_image_captionValidationFailureMessages = value;   
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "image_captionValidationFailureMessages", oldValue, value));
            // Only execute calculateIsValid if it has been called before, to update the validationFailureMessages for
            // the entire entity.
            if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
            {
                model_internal::_instance.model_internal::isValid_der = model_internal::_instance.model_internal::calculateIsValid();
            }
        }
    }

    [Bindable(event="propertyChange")]   
    public function get url_dxfStyle():com.adobe.fiber.styles.Style
    {
        return model_internal::_nullStyle;
    }

    public function get url_dxfValidator() : StyleValidator
    {
        return model_internal::_url_dxfValidator;
    }

    model_internal function set _url_dxfIsValid_der(value:Boolean):void 
    {
        var oldValue:Boolean = model_internal::_url_dxfIsValid;         
        if (oldValue !== value)
        {
            model_internal::_url_dxfIsValid = value;
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "url_dxfIsValid", oldValue, value));
        }                             
    }

    [Bindable(event="propertyChange")]
    public function get url_dxfIsValid():Boolean
    {
        if (!model_internal::_url_dxfIsValidCacheInitialized)
        {
            model_internal::calculateUrl_dxfIsValid();
        }

        return model_internal::_url_dxfIsValid;
    }

    model_internal function calculateUrl_dxfIsValid():void
    {
        var valRes:ValidationResultEvent = model_internal::_url_dxfValidator.validate(model_internal::_instance.url_dxf)
        model_internal::_url_dxfIsValid_der = (valRes.results == null);
        model_internal::_url_dxfIsValidCacheInitialized = true;
        if (valRes.results == null)
             model_internal::url_dxfValidationFailureMessages_der = emptyArray;
        else
        {
            var _valFailures:Array = new Array();
            for (var a:int = 0 ; a<valRes.results.length ; a++)
            {
                _valFailures.push(valRes.results[a].errorMessage);
            }
            model_internal::url_dxfValidationFailureMessages_der = _valFailures;
        }
    }

    [Bindable(event="propertyChange")]
    public function get url_dxfValidationFailureMessages():Array
    {
        if (model_internal::_url_dxfValidationFailureMessages == null)
            model_internal::calculateUrl_dxfIsValid();

        return _url_dxfValidationFailureMessages;
    }

    model_internal function set url_dxfValidationFailureMessages_der(value:Array) : void
    {
        var oldValue:Array = model_internal::_url_dxfValidationFailureMessages;

        var needUpdate : Boolean = false;
        if (oldValue == null)
            needUpdate = true;
    
        // avoid firing the event when old and new value are different empty arrays
        if (!needUpdate && (oldValue !== value && (oldValue.length > 0 || value.length > 0)))
        {
            if (oldValue.length == value.length)
            {
                for (var a:int=0; a < oldValue.length; a++)
                {
                    if (oldValue[a] !== value[a])
                    {
                        needUpdate = true;
                        break;
                    }
                }
            }
            else
            {
                needUpdate = true;
            }
        }

        if (needUpdate)
        {
            model_internal::_url_dxfValidationFailureMessages = value;   
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "url_dxfValidationFailureMessages", oldValue, value));
            // Only execute calculateIsValid if it has been called before, to update the validationFailureMessages for
            // the entire entity.
            if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
            {
                model_internal::_instance.model_internal::isValid_der = model_internal::_instance.model_internal::calculateIsValid();
            }
        }
    }

    [Bindable(event="propertyChange")]   
    public function get url_dwgStyle():com.adobe.fiber.styles.Style
    {
        return model_internal::_nullStyle;
    }

    public function get url_dwgValidator() : StyleValidator
    {
        return model_internal::_url_dwgValidator;
    }

    model_internal function set _url_dwgIsValid_der(value:Boolean):void 
    {
        var oldValue:Boolean = model_internal::_url_dwgIsValid;         
        if (oldValue !== value)
        {
            model_internal::_url_dwgIsValid = value;
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "url_dwgIsValid", oldValue, value));
        }                             
    }

    [Bindable(event="propertyChange")]
    public function get url_dwgIsValid():Boolean
    {
        if (!model_internal::_url_dwgIsValidCacheInitialized)
        {
            model_internal::calculateUrl_dwgIsValid();
        }

        return model_internal::_url_dwgIsValid;
    }

    model_internal function calculateUrl_dwgIsValid():void
    {
        var valRes:ValidationResultEvent = model_internal::_url_dwgValidator.validate(model_internal::_instance.url_dwg)
        model_internal::_url_dwgIsValid_der = (valRes.results == null);
        model_internal::_url_dwgIsValidCacheInitialized = true;
        if (valRes.results == null)
             model_internal::url_dwgValidationFailureMessages_der = emptyArray;
        else
        {
            var _valFailures:Array = new Array();
            for (var a:int = 0 ; a<valRes.results.length ; a++)
            {
                _valFailures.push(valRes.results[a].errorMessage);
            }
            model_internal::url_dwgValidationFailureMessages_der = _valFailures;
        }
    }

    [Bindable(event="propertyChange")]
    public function get url_dwgValidationFailureMessages():Array
    {
        if (model_internal::_url_dwgValidationFailureMessages == null)
            model_internal::calculateUrl_dwgIsValid();

        return _url_dwgValidationFailureMessages;
    }

    model_internal function set url_dwgValidationFailureMessages_der(value:Array) : void
    {
        var oldValue:Array = model_internal::_url_dwgValidationFailureMessages;

        var needUpdate : Boolean = false;
        if (oldValue == null)
            needUpdate = true;
    
        // avoid firing the event when old and new value are different empty arrays
        if (!needUpdate && (oldValue !== value && (oldValue.length > 0 || value.length > 0)))
        {
            if (oldValue.length == value.length)
            {
                for (var a:int=0; a < oldValue.length; a++)
                {
                    if (oldValue[a] !== value[a])
                    {
                        needUpdate = true;
                        break;
                    }
                }
            }
            else
            {
                needUpdate = true;
            }
        }

        if (needUpdate)
        {
            model_internal::_url_dwgValidationFailureMessages = value;   
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "url_dwgValidationFailureMessages", oldValue, value));
            // Only execute calculateIsValid if it has been called before, to update the validationFailureMessages for
            // the entire entity.
            if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
            {
                model_internal::_instance.model_internal::isValid_der = model_internal::_instance.model_internal::calculateIsValid();
            }
        }
    }

    [Bindable(event="propertyChange")]   
    public function get url_plaStyle():com.adobe.fiber.styles.Style
    {
        return model_internal::_nullStyle;
    }

    public function get url_plaValidator() : StyleValidator
    {
        return model_internal::_url_plaValidator;
    }

    model_internal function set _url_plaIsValid_der(value:Boolean):void 
    {
        var oldValue:Boolean = model_internal::_url_plaIsValid;         
        if (oldValue !== value)
        {
            model_internal::_url_plaIsValid = value;
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "url_plaIsValid", oldValue, value));
        }                             
    }

    [Bindable(event="propertyChange")]
    public function get url_plaIsValid():Boolean
    {
        if (!model_internal::_url_plaIsValidCacheInitialized)
        {
            model_internal::calculateUrl_plaIsValid();
        }

        return model_internal::_url_plaIsValid;
    }

    model_internal function calculateUrl_plaIsValid():void
    {
        var valRes:ValidationResultEvent = model_internal::_url_plaValidator.validate(model_internal::_instance.url_pla)
        model_internal::_url_plaIsValid_der = (valRes.results == null);
        model_internal::_url_plaIsValidCacheInitialized = true;
        if (valRes.results == null)
             model_internal::url_plaValidationFailureMessages_der = emptyArray;
        else
        {
            var _valFailures:Array = new Array();
            for (var a:int = 0 ; a<valRes.results.length ; a++)
            {
                _valFailures.push(valRes.results[a].errorMessage);
            }
            model_internal::url_plaValidationFailureMessages_der = _valFailures;
        }
    }

    [Bindable(event="propertyChange")]
    public function get url_plaValidationFailureMessages():Array
    {
        if (model_internal::_url_plaValidationFailureMessages == null)
            model_internal::calculateUrl_plaIsValid();

        return _url_plaValidationFailureMessages;
    }

    model_internal function set url_plaValidationFailureMessages_der(value:Array) : void
    {
        var oldValue:Array = model_internal::_url_plaValidationFailureMessages;

        var needUpdate : Boolean = false;
        if (oldValue == null)
            needUpdate = true;
    
        // avoid firing the event when old and new value are different empty arrays
        if (!needUpdate && (oldValue !== value && (oldValue.length > 0 || value.length > 0)))
        {
            if (oldValue.length == value.length)
            {
                for (var a:int=0; a < oldValue.length; a++)
                {
                    if (oldValue[a] !== value[a])
                    {
                        needUpdate = true;
                        break;
                    }
                }
            }
            else
            {
                needUpdate = true;
            }
        }

        if (needUpdate)
        {
            model_internal::_url_plaValidationFailureMessages = value;   
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "url_plaValidationFailureMessages", oldValue, value));
            // Only execute calculateIsValid if it has been called before, to update the validationFailureMessages for
            // the entire entity.
            if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
            {
                model_internal::_instance.model_internal::isValid_der = model_internal::_instance.model_internal::calculateIsValid();
            }
        }
    }

    [Bindable(event="propertyChange")]   
    public function get url_pdfStyle():com.adobe.fiber.styles.Style
    {
        return model_internal::_nullStyle;
    }

    public function get url_pdfValidator() : StyleValidator
    {
        return model_internal::_url_pdfValidator;
    }

    model_internal function set _url_pdfIsValid_der(value:Boolean):void 
    {
        var oldValue:Boolean = model_internal::_url_pdfIsValid;         
        if (oldValue !== value)
        {
            model_internal::_url_pdfIsValid = value;
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "url_pdfIsValid", oldValue, value));
        }                             
    }

    [Bindable(event="propertyChange")]
    public function get url_pdfIsValid():Boolean
    {
        if (!model_internal::_url_pdfIsValidCacheInitialized)
        {
            model_internal::calculateUrl_pdfIsValid();
        }

        return model_internal::_url_pdfIsValid;
    }

    model_internal function calculateUrl_pdfIsValid():void
    {
        var valRes:ValidationResultEvent = model_internal::_url_pdfValidator.validate(model_internal::_instance.url_pdf)
        model_internal::_url_pdfIsValid_der = (valRes.results == null);
        model_internal::_url_pdfIsValidCacheInitialized = true;
        if (valRes.results == null)
             model_internal::url_pdfValidationFailureMessages_der = emptyArray;
        else
        {
            var _valFailures:Array = new Array();
            for (var a:int = 0 ; a<valRes.results.length ; a++)
            {
                _valFailures.push(valRes.results[a].errorMessage);
            }
            model_internal::url_pdfValidationFailureMessages_der = _valFailures;
        }
    }

    [Bindable(event="propertyChange")]
    public function get url_pdfValidationFailureMessages():Array
    {
        if (model_internal::_url_pdfValidationFailureMessages == null)
            model_internal::calculateUrl_pdfIsValid();

        return _url_pdfValidationFailureMessages;
    }

    model_internal function set url_pdfValidationFailureMessages_der(value:Array) : void
    {
        var oldValue:Array = model_internal::_url_pdfValidationFailureMessages;

        var needUpdate : Boolean = false;
        if (oldValue == null)
            needUpdate = true;
    
        // avoid firing the event when old and new value are different empty arrays
        if (!needUpdate && (oldValue !== value && (oldValue.length > 0 || value.length > 0)))
        {
            if (oldValue.length == value.length)
            {
                for (var a:int=0; a < oldValue.length; a++)
                {
                    if (oldValue[a] !== value[a])
                    {
                        needUpdate = true;
                        break;
                    }
                }
            }
            else
            {
                needUpdate = true;
            }
        }

        if (needUpdate)
        {
            model_internal::_url_pdfValidationFailureMessages = value;   
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "url_pdfValidationFailureMessages", oldValue, value));
            // Only execute calculateIsValid if it has been called before, to update the validationFailureMessages for
            // the entire entity.
            if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
            {
                model_internal::_instance.model_internal::isValid_der = model_internal::_instance.model_internal::calculateIsValid();
            }
        }
    }

    [Bindable(event="propertyChange")]   
    public function get url_jpgStyle():com.adobe.fiber.styles.Style
    {
        return model_internal::_nullStyle;
    }

    public function get url_jpgValidator() : StyleValidator
    {
        return model_internal::_url_jpgValidator;
    }

    model_internal function set _url_jpgIsValid_der(value:Boolean):void 
    {
        var oldValue:Boolean = model_internal::_url_jpgIsValid;         
        if (oldValue !== value)
        {
            model_internal::_url_jpgIsValid = value;
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "url_jpgIsValid", oldValue, value));
        }                             
    }

    [Bindable(event="propertyChange")]
    public function get url_jpgIsValid():Boolean
    {
        if (!model_internal::_url_jpgIsValidCacheInitialized)
        {
            model_internal::calculateUrl_jpgIsValid();
        }

        return model_internal::_url_jpgIsValid;
    }

    model_internal function calculateUrl_jpgIsValid():void
    {
        var valRes:ValidationResultEvent = model_internal::_url_jpgValidator.validate(model_internal::_instance.url_jpg)
        model_internal::_url_jpgIsValid_der = (valRes.results == null);
        model_internal::_url_jpgIsValidCacheInitialized = true;
        if (valRes.results == null)
             model_internal::url_jpgValidationFailureMessages_der = emptyArray;
        else
        {
            var _valFailures:Array = new Array();
            for (var a:int = 0 ; a<valRes.results.length ; a++)
            {
                _valFailures.push(valRes.results[a].errorMessage);
            }
            model_internal::url_jpgValidationFailureMessages_der = _valFailures;
        }
    }

    [Bindable(event="propertyChange")]
    public function get url_jpgValidationFailureMessages():Array
    {
        if (model_internal::_url_jpgValidationFailureMessages == null)
            model_internal::calculateUrl_jpgIsValid();

        return _url_jpgValidationFailureMessages;
    }

    model_internal function set url_jpgValidationFailureMessages_der(value:Array) : void
    {
        var oldValue:Array = model_internal::_url_jpgValidationFailureMessages;

        var needUpdate : Boolean = false;
        if (oldValue == null)
            needUpdate = true;
    
        // avoid firing the event when old and new value are different empty arrays
        if (!needUpdate && (oldValue !== value && (oldValue.length > 0 || value.length > 0)))
        {
            if (oldValue.length == value.length)
            {
                for (var a:int=0; a < oldValue.length; a++)
                {
                    if (oldValue[a] !== value[a])
                    {
                        needUpdate = true;
                        break;
                    }
                }
            }
            else
            {
                needUpdate = true;
            }
        }

        if (needUpdate)
        {
            model_internal::_url_jpgValidationFailureMessages = value;   
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "url_jpgValidationFailureMessages", oldValue, value));
            // Only execute calculateIsValid if it has been called before, to update the validationFailureMessages for
            // the entire entity.
            if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
            {
                model_internal::_instance.model_internal::isValid_der = model_internal::_instance.model_internal::calculateIsValid();
            }
        }
    }

    [Bindable(event="propertyChange")]   
    public function get rwStyle():com.adobe.fiber.styles.Style
    {
        return model_internal::_nullStyle;
    }

    public function get rwValidator() : StyleValidator
    {
        return model_internal::_rwValidator;
    }

    model_internal function set _rwIsValid_der(value:Boolean):void 
    {
        var oldValue:Boolean = model_internal::_rwIsValid;         
        if (oldValue !== value)
        {
            model_internal::_rwIsValid = value;
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "rwIsValid", oldValue, value));
        }                             
    }

    [Bindable(event="propertyChange")]
    public function get rwIsValid():Boolean
    {
        if (!model_internal::_rwIsValidCacheInitialized)
        {
            model_internal::calculateRwIsValid();
        }

        return model_internal::_rwIsValid;
    }

    model_internal function calculateRwIsValid():void
    {
        var valRes:ValidationResultEvent = model_internal::_rwValidator.validate(model_internal::_instance.rw)
        model_internal::_rwIsValid_der = (valRes.results == null);
        model_internal::_rwIsValidCacheInitialized = true;
        if (valRes.results == null)
             model_internal::rwValidationFailureMessages_der = emptyArray;
        else
        {
            var _valFailures:Array = new Array();
            for (var a:int = 0 ; a<valRes.results.length ; a++)
            {
                _valFailures.push(valRes.results[a].errorMessage);
            }
            model_internal::rwValidationFailureMessages_der = _valFailures;
        }
    }

    [Bindable(event="propertyChange")]
    public function get rwValidationFailureMessages():Array
    {
        if (model_internal::_rwValidationFailureMessages == null)
            model_internal::calculateRwIsValid();

        return _rwValidationFailureMessages;
    }

    model_internal function set rwValidationFailureMessages_der(value:Array) : void
    {
        var oldValue:Array = model_internal::_rwValidationFailureMessages;

        var needUpdate : Boolean = false;
        if (oldValue == null)
            needUpdate = true;
    
        // avoid firing the event when old and new value are different empty arrays
        if (!needUpdate && (oldValue !== value && (oldValue.length > 0 || value.length > 0)))
        {
            if (oldValue.length == value.length)
            {
                for (var a:int=0; a < oldValue.length; a++)
                {
                    if (oldValue[a] !== value[a])
                    {
                        needUpdate = true;
                        break;
                    }
                }
            }
            else
            {
                needUpdate = true;
            }
        }

        if (needUpdate)
        {
            model_internal::_rwValidationFailureMessages = value;   
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "rwValidationFailureMessages", oldValue, value));
            // Only execute calculateIsValid if it has been called before, to update the validationFailureMessages for
            // the entire entity.
            if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
            {
                model_internal::_instance.model_internal::isValid_der = model_internal::_instance.model_internal::calculateIsValid();
            }
        }
    }

    [Bindable(event="propertyChange")]   
    public function get lntwStyle():com.adobe.fiber.styles.Style
    {
        return model_internal::_nullStyle;
    }

    public function get lntwValidator() : StyleValidator
    {
        return model_internal::_lntwValidator;
    }

    model_internal function set _lntwIsValid_der(value:Boolean):void 
    {
        var oldValue:Boolean = model_internal::_lntwIsValid;         
        if (oldValue !== value)
        {
            model_internal::_lntwIsValid = value;
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "lntwIsValid", oldValue, value));
        }                             
    }

    [Bindable(event="propertyChange")]
    public function get lntwIsValid():Boolean
    {
        if (!model_internal::_lntwIsValidCacheInitialized)
        {
            model_internal::calculateLntwIsValid();
        }

        return model_internal::_lntwIsValid;
    }

    model_internal function calculateLntwIsValid():void
    {
        var valRes:ValidationResultEvent = model_internal::_lntwValidator.validate(model_internal::_instance.lntw)
        model_internal::_lntwIsValid_der = (valRes.results == null);
        model_internal::_lntwIsValidCacheInitialized = true;
        if (valRes.results == null)
             model_internal::lntwValidationFailureMessages_der = emptyArray;
        else
        {
            var _valFailures:Array = new Array();
            for (var a:int = 0 ; a<valRes.results.length ; a++)
            {
                _valFailures.push(valRes.results[a].errorMessage);
            }
            model_internal::lntwValidationFailureMessages_der = _valFailures;
        }
    }

    [Bindable(event="propertyChange")]
    public function get lntwValidationFailureMessages():Array
    {
        if (model_internal::_lntwValidationFailureMessages == null)
            model_internal::calculateLntwIsValid();

        return _lntwValidationFailureMessages;
    }

    model_internal function set lntwValidationFailureMessages_der(value:Array) : void
    {
        var oldValue:Array = model_internal::_lntwValidationFailureMessages;

        var needUpdate : Boolean = false;
        if (oldValue == null)
            needUpdate = true;
    
        // avoid firing the event when old and new value are different empty arrays
        if (!needUpdate && (oldValue !== value && (oldValue.length > 0 || value.length > 0)))
        {
            if (oldValue.length == value.length)
            {
                for (var a:int=0; a < oldValue.length; a++)
                {
                    if (oldValue[a] !== value[a])
                    {
                        needUpdate = true;
                        break;
                    }
                }
            }
            else
            {
                needUpdate = true;
            }
        }

        if (needUpdate)
        {
            model_internal::_lntwValidationFailureMessages = value;   
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "lntwValidationFailureMessages", oldValue, value));
            // Only execute calculateIsValid if it has been called before, to update the validationFailureMessages for
            // the entire entity.
            if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
            {
                model_internal::_instance.model_internal::isValid_der = model_internal::_instance.model_internal::calculateIsValid();
            }
        }
    }

    [Bindable(event="propertyChange")]   
    public function get reiStyle():com.adobe.fiber.styles.Style
    {
        return model_internal::_nullStyle;
    }

    [Bindable(event="propertyChange")]   
    public function get notesStyle():com.adobe.fiber.styles.Style
    {
        return model_internal::_nullStyle;
    }

    public function get notesValidator() : StyleValidator
    {
        return model_internal::_notesValidator;
    }

    model_internal function set _notesIsValid_der(value:Boolean):void 
    {
        var oldValue:Boolean = model_internal::_notesIsValid;         
        if (oldValue !== value)
        {
            model_internal::_notesIsValid = value;
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "notesIsValid", oldValue, value));
        }                             
    }

    [Bindable(event="propertyChange")]
    public function get notesIsValid():Boolean
    {
        if (!model_internal::_notesIsValidCacheInitialized)
        {
            model_internal::calculateNotesIsValid();
        }

        return model_internal::_notesIsValid;
    }

    model_internal function calculateNotesIsValid():void
    {
        var valRes:ValidationResultEvent = model_internal::_notesValidator.validate(model_internal::_instance.notes)
        model_internal::_notesIsValid_der = (valRes.results == null);
        model_internal::_notesIsValidCacheInitialized = true;
        if (valRes.results == null)
             model_internal::notesValidationFailureMessages_der = emptyArray;
        else
        {
            var _valFailures:Array = new Array();
            for (var a:int = 0 ; a<valRes.results.length ; a++)
            {
                _valFailures.push(valRes.results[a].errorMessage);
            }
            model_internal::notesValidationFailureMessages_der = _valFailures;
        }
    }

    [Bindable(event="propertyChange")]
    public function get notesValidationFailureMessages():Array
    {
        if (model_internal::_notesValidationFailureMessages == null)
            model_internal::calculateNotesIsValid();

        return _notesValidationFailureMessages;
    }

    model_internal function set notesValidationFailureMessages_der(value:Array) : void
    {
        var oldValue:Array = model_internal::_notesValidationFailureMessages;

        var needUpdate : Boolean = false;
        if (oldValue == null)
            needUpdate = true;
    
        // avoid firing the event when old and new value are different empty arrays
        if (!needUpdate && (oldValue !== value && (oldValue.length > 0 || value.length > 0)))
        {
            if (oldValue.length == value.length)
            {
                for (var a:int=0; a < oldValue.length; a++)
                {
                    if (oldValue[a] !== value[a])
                    {
                        needUpdate = true;
                        break;
                    }
                }
            }
            else
            {
                needUpdate = true;
            }
        }

        if (needUpdate)
        {
            model_internal::_notesValidationFailureMessages = value;   
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "notesValidationFailureMessages", oldValue, value));
            // Only execute calculateIsValid if it has been called before, to update the validationFailureMessages for
            // the entire entity.
            if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
            {
                model_internal::_instance.model_internal::isValid_der = model_internal::_instance.model_internal::calculateIsValid();
            }
        }
    }

    [Bindable(event="propertyChange")]   
    public function get physicsStyle():com.adobe.fiber.styles.Style
    {
        return model_internal::_nullStyle;
    }

    public function get physicsValidator() : StyleValidator
    {
        return model_internal::_physicsValidator;
    }

    model_internal function set _physicsIsValid_der(value:Boolean):void 
    {
        var oldValue:Boolean = model_internal::_physicsIsValid;         
        if (oldValue !== value)
        {
            model_internal::_physicsIsValid = value;
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "physicsIsValid", oldValue, value));
        }                             
    }

    [Bindable(event="propertyChange")]
    public function get physicsIsValid():Boolean
    {
        if (!model_internal::_physicsIsValidCacheInitialized)
        {
            model_internal::calculatePhysicsIsValid();
        }

        return model_internal::_physicsIsValid;
    }

    model_internal function calculatePhysicsIsValid():void
    {
        var valRes:ValidationResultEvent = model_internal::_physicsValidator.validate(model_internal::_instance.physics)
        model_internal::_physicsIsValid_der = (valRes.results == null);
        model_internal::_physicsIsValidCacheInitialized = true;
        if (valRes.results == null)
             model_internal::physicsValidationFailureMessages_der = emptyArray;
        else
        {
            var _valFailures:Array = new Array();
            for (var a:int = 0 ; a<valRes.results.length ; a++)
            {
                _valFailures.push(valRes.results[a].errorMessage);
            }
            model_internal::physicsValidationFailureMessages_der = _valFailures;
        }
    }

    [Bindable(event="propertyChange")]
    public function get physicsValidationFailureMessages():Array
    {
        if (model_internal::_physicsValidationFailureMessages == null)
            model_internal::calculatePhysicsIsValid();

        return _physicsValidationFailureMessages;
    }

    model_internal function set physicsValidationFailureMessages_der(value:Array) : void
    {
        var oldValue:Array = model_internal::_physicsValidationFailureMessages;

        var needUpdate : Boolean = false;
        if (oldValue == null)
            needUpdate = true;
    
        // avoid firing the event when old and new value are different empty arrays
        if (!needUpdate && (oldValue !== value && (oldValue.length > 0 || value.length > 0)))
        {
            if (oldValue.length == value.length)
            {
                for (var a:int=0; a < oldValue.length; a++)
                {
                    if (oldValue[a] !== value[a])
                    {
                        needUpdate = true;
                        break;
                    }
                }
            }
            else
            {
                needUpdate = true;
            }
        }

        if (needUpdate)
        {
            model_internal::_physicsValidationFailureMessages = value;   
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "physicsValidationFailureMessages", oldValue, value));
            // Only execute calculateIsValid if it has been called before, to update the validationFailureMessages for
            // the entire entity.
            if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
            {
                model_internal::_instance.model_internal::isValid_der = model_internal::_instance.model_internal::calculateIsValid();
            }
        }
    }

    [Bindable(event="propertyChange")]   
    public function get add_notesStyle():com.adobe.fiber.styles.Style
    {
        return model_internal::_nullStyle;
    }

    public function get add_notesValidator() : StyleValidator
    {
        return model_internal::_add_notesValidator;
    }

    model_internal function set _add_notesIsValid_der(value:Boolean):void 
    {
        var oldValue:Boolean = model_internal::_add_notesIsValid;         
        if (oldValue !== value)
        {
            model_internal::_add_notesIsValid = value;
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "add_notesIsValid", oldValue, value));
        }                             
    }

    [Bindable(event="propertyChange")]
    public function get add_notesIsValid():Boolean
    {
        if (!model_internal::_add_notesIsValidCacheInitialized)
        {
            model_internal::calculateAdd_notesIsValid();
        }

        return model_internal::_add_notesIsValid;
    }

    model_internal function calculateAdd_notesIsValid():void
    {
        var valRes:ValidationResultEvent = model_internal::_add_notesValidator.validate(model_internal::_instance.add_notes)
        model_internal::_add_notesIsValid_der = (valRes.results == null);
        model_internal::_add_notesIsValidCacheInitialized = true;
        if (valRes.results == null)
             model_internal::add_notesValidationFailureMessages_der = emptyArray;
        else
        {
            var _valFailures:Array = new Array();
            for (var a:int = 0 ; a<valRes.results.length ; a++)
            {
                _valFailures.push(valRes.results[a].errorMessage);
            }
            model_internal::add_notesValidationFailureMessages_der = _valFailures;
        }
    }

    [Bindable(event="propertyChange")]
    public function get add_notesValidationFailureMessages():Array
    {
        if (model_internal::_add_notesValidationFailureMessages == null)
            model_internal::calculateAdd_notesIsValid();

        return _add_notesValidationFailureMessages;
    }

    model_internal function set add_notesValidationFailureMessages_der(value:Array) : void
    {
        var oldValue:Array = model_internal::_add_notesValidationFailureMessages;

        var needUpdate : Boolean = false;
        if (oldValue == null)
            needUpdate = true;
    
        // avoid firing the event when old and new value are different empty arrays
        if (!needUpdate && (oldValue !== value && (oldValue.length > 0 || value.length > 0)))
        {
            if (oldValue.length == value.length)
            {
                for (var a:int=0; a < oldValue.length; a++)
                {
                    if (oldValue[a] !== value[a])
                    {
                        needUpdate = true;
                        break;
                    }
                }
            }
            else
            {
                needUpdate = true;
            }
        }

        if (needUpdate)
        {
            model_internal::_add_notesValidationFailureMessages = value;   
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "add_notesValidationFailureMessages", oldValue, value));
            // Only execute calculateIsValid if it has been called before, to update the validationFailureMessages for
            // the entire entity.
            if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
            {
                model_internal::_instance.model_internal::isValid_der = model_internal::_instance.model_internal::calculateIsValid();
            }
        }
    }

    [Bindable(event="propertyChange")]   
    public function get rel_infoStyle():com.adobe.fiber.styles.Style
    {
        return model_internal::_nullStyle;
    }

    public function get rel_infoValidator() : StyleValidator
    {
        return model_internal::_rel_infoValidator;
    }

    model_internal function set _rel_infoIsValid_der(value:Boolean):void 
    {
        var oldValue:Boolean = model_internal::_rel_infoIsValid;         
        if (oldValue !== value)
        {
            model_internal::_rel_infoIsValid = value;
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "rel_infoIsValid", oldValue, value));
        }                             
    }

    [Bindable(event="propertyChange")]
    public function get rel_infoIsValid():Boolean
    {
        if (!model_internal::_rel_infoIsValidCacheInitialized)
        {
            model_internal::calculateRel_infoIsValid();
        }

        return model_internal::_rel_infoIsValid;
    }

    model_internal function calculateRel_infoIsValid():void
    {
        var valRes:ValidationResultEvent = model_internal::_rel_infoValidator.validate(model_internal::_instance.rel_info)
        model_internal::_rel_infoIsValid_der = (valRes.results == null);
        model_internal::_rel_infoIsValidCacheInitialized = true;
        if (valRes.results == null)
             model_internal::rel_infoValidationFailureMessages_der = emptyArray;
        else
        {
            var _valFailures:Array = new Array();
            for (var a:int = 0 ; a<valRes.results.length ; a++)
            {
                _valFailures.push(valRes.results[a].errorMessage);
            }
            model_internal::rel_infoValidationFailureMessages_der = _valFailures;
        }
    }

    [Bindable(event="propertyChange")]
    public function get rel_infoValidationFailureMessages():Array
    {
        if (model_internal::_rel_infoValidationFailureMessages == null)
            model_internal::calculateRel_infoIsValid();

        return _rel_infoValidationFailureMessages;
    }

    model_internal function set rel_infoValidationFailureMessages_der(value:Array) : void
    {
        var oldValue:Array = model_internal::_rel_infoValidationFailureMessages;

        var needUpdate : Boolean = false;
        if (oldValue == null)
            needUpdate = true;
    
        // avoid firing the event when old and new value are different empty arrays
        if (!needUpdate && (oldValue !== value && (oldValue.length > 0 || value.length > 0)))
        {
            if (oldValue.length == value.length)
            {
                for (var a:int=0; a < oldValue.length; a++)
                {
                    if (oldValue[a] !== value[a])
                    {
                        needUpdate = true;
                        break;
                    }
                }
            }
            else
            {
                needUpdate = true;
            }
        }

        if (needUpdate)
        {
            model_internal::_rel_infoValidationFailureMessages = value;   
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "rel_infoValidationFailureMessages", oldValue, value));
            // Only execute calculateIsValid if it has been called before, to update the validationFailureMessages for
            // the entire entity.
            if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
            {
                model_internal::_instance.model_internal::isValid_der = model_internal::_instance.model_internal::calculateIsValid();
            }
        }
    }

    [Bindable(event="propertyChange")]   
    public function get layer_a_dimensionsStyle():com.adobe.fiber.styles.Style
    {
        return model_internal::_nullStyle;
    }

    public function get layer_a_dimensionsValidator() : StyleValidator
    {
        return model_internal::_layer_a_dimensionsValidator;
    }

    model_internal function set _layer_a_dimensionsIsValid_der(value:Boolean):void 
    {
        var oldValue:Boolean = model_internal::_layer_a_dimensionsIsValid;         
        if (oldValue !== value)
        {
            model_internal::_layer_a_dimensionsIsValid = value;
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "layer_a_dimensionsIsValid", oldValue, value));
        }                             
    }

    [Bindable(event="propertyChange")]
    public function get layer_a_dimensionsIsValid():Boolean
    {
        if (!model_internal::_layer_a_dimensionsIsValidCacheInitialized)
        {
            model_internal::calculateLayer_a_dimensionsIsValid();
        }

        return model_internal::_layer_a_dimensionsIsValid;
    }

    model_internal function calculateLayer_a_dimensionsIsValid():void
    {
        var valRes:ValidationResultEvent = model_internal::_layer_a_dimensionsValidator.validate(model_internal::_instance.layer_a_dimensions)
        model_internal::_layer_a_dimensionsIsValid_der = (valRes.results == null);
        model_internal::_layer_a_dimensionsIsValidCacheInitialized = true;
        if (valRes.results == null)
             model_internal::layer_a_dimensionsValidationFailureMessages_der = emptyArray;
        else
        {
            var _valFailures:Array = new Array();
            for (var a:int = 0 ; a<valRes.results.length ; a++)
            {
                _valFailures.push(valRes.results[a].errorMessage);
            }
            model_internal::layer_a_dimensionsValidationFailureMessages_der = _valFailures;
        }
    }

    [Bindable(event="propertyChange")]
    public function get layer_a_dimensionsValidationFailureMessages():Array
    {
        if (model_internal::_layer_a_dimensionsValidationFailureMessages == null)
            model_internal::calculateLayer_a_dimensionsIsValid();

        return _layer_a_dimensionsValidationFailureMessages;
    }

    model_internal function set layer_a_dimensionsValidationFailureMessages_der(value:Array) : void
    {
        var oldValue:Array = model_internal::_layer_a_dimensionsValidationFailureMessages;

        var needUpdate : Boolean = false;
        if (oldValue == null)
            needUpdate = true;
    
        // avoid firing the event when old and new value are different empty arrays
        if (!needUpdate && (oldValue !== value && (oldValue.length > 0 || value.length > 0)))
        {
            if (oldValue.length == value.length)
            {
                for (var a:int=0; a < oldValue.length; a++)
                {
                    if (oldValue[a] !== value[a])
                    {
                        needUpdate = true;
                        break;
                    }
                }
            }
            else
            {
                needUpdate = true;
            }
        }

        if (needUpdate)
        {
            model_internal::_layer_a_dimensionsValidationFailureMessages = value;   
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "layer_a_dimensionsValidationFailureMessages", oldValue, value));
            // Only execute calculateIsValid if it has been called before, to update the validationFailureMessages for
            // the entire entity.
            if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
            {
                model_internal::_instance.model_internal::isValid_der = model_internal::_instance.model_internal::calculateIsValid();
            }
        }
    }

    [Bindable(event="propertyChange")]   
    public function get layer_b_dimensionsStyle():com.adobe.fiber.styles.Style
    {
        return model_internal::_nullStyle;
    }

    public function get layer_b_dimensionsValidator() : StyleValidator
    {
        return model_internal::_layer_b_dimensionsValidator;
    }

    model_internal function set _layer_b_dimensionsIsValid_der(value:Boolean):void 
    {
        var oldValue:Boolean = model_internal::_layer_b_dimensionsIsValid;         
        if (oldValue !== value)
        {
            model_internal::_layer_b_dimensionsIsValid = value;
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "layer_b_dimensionsIsValid", oldValue, value));
        }                             
    }

    [Bindable(event="propertyChange")]
    public function get layer_b_dimensionsIsValid():Boolean
    {
        if (!model_internal::_layer_b_dimensionsIsValidCacheInitialized)
        {
            model_internal::calculateLayer_b_dimensionsIsValid();
        }

        return model_internal::_layer_b_dimensionsIsValid;
    }

    model_internal function calculateLayer_b_dimensionsIsValid():void
    {
        var valRes:ValidationResultEvent = model_internal::_layer_b_dimensionsValidator.validate(model_internal::_instance.layer_b_dimensions)
        model_internal::_layer_b_dimensionsIsValid_der = (valRes.results == null);
        model_internal::_layer_b_dimensionsIsValidCacheInitialized = true;
        if (valRes.results == null)
             model_internal::layer_b_dimensionsValidationFailureMessages_der = emptyArray;
        else
        {
            var _valFailures:Array = new Array();
            for (var a:int = 0 ; a<valRes.results.length ; a++)
            {
                _valFailures.push(valRes.results[a].errorMessage);
            }
            model_internal::layer_b_dimensionsValidationFailureMessages_der = _valFailures;
        }
    }

    [Bindable(event="propertyChange")]
    public function get layer_b_dimensionsValidationFailureMessages():Array
    {
        if (model_internal::_layer_b_dimensionsValidationFailureMessages == null)
            model_internal::calculateLayer_b_dimensionsIsValid();

        return _layer_b_dimensionsValidationFailureMessages;
    }

    model_internal function set layer_b_dimensionsValidationFailureMessages_der(value:Array) : void
    {
        var oldValue:Array = model_internal::_layer_b_dimensionsValidationFailureMessages;

        var needUpdate : Boolean = false;
        if (oldValue == null)
            needUpdate = true;
    
        // avoid firing the event when old and new value are different empty arrays
        if (!needUpdate && (oldValue !== value && (oldValue.length > 0 || value.length > 0)))
        {
            if (oldValue.length == value.length)
            {
                for (var a:int=0; a < oldValue.length; a++)
                {
                    if (oldValue[a] !== value[a])
                    {
                        needUpdate = true;
                        break;
                    }
                }
            }
            else
            {
                needUpdate = true;
            }
        }

        if (needUpdate)
        {
            model_internal::_layer_b_dimensionsValidationFailureMessages = value;   
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "layer_b_dimensionsValidationFailureMessages", oldValue, value));
            // Only execute calculateIsValid if it has been called before, to update the validationFailureMessages for
            // the entire entity.
            if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
            {
                model_internal::_instance.model_internal::isValid_der = model_internal::_instance.model_internal::calculateIsValid();
            }
        }
    }

    [Bindable(event="propertyChange")]   
    public function get layer_c_dimensionsStyle():com.adobe.fiber.styles.Style
    {
        return model_internal::_nullStyle;
    }

    public function get layer_c_dimensionsValidator() : StyleValidator
    {
        return model_internal::_layer_c_dimensionsValidator;
    }

    model_internal function set _layer_c_dimensionsIsValid_der(value:Boolean):void 
    {
        var oldValue:Boolean = model_internal::_layer_c_dimensionsIsValid;         
        if (oldValue !== value)
        {
            model_internal::_layer_c_dimensionsIsValid = value;
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "layer_c_dimensionsIsValid", oldValue, value));
        }                             
    }

    [Bindable(event="propertyChange")]
    public function get layer_c_dimensionsIsValid():Boolean
    {
        if (!model_internal::_layer_c_dimensionsIsValidCacheInitialized)
        {
            model_internal::calculateLayer_c_dimensionsIsValid();
        }

        return model_internal::_layer_c_dimensionsIsValid;
    }

    model_internal function calculateLayer_c_dimensionsIsValid():void
    {
        var valRes:ValidationResultEvent = model_internal::_layer_c_dimensionsValidator.validate(model_internal::_instance.layer_c_dimensions)
        model_internal::_layer_c_dimensionsIsValid_der = (valRes.results == null);
        model_internal::_layer_c_dimensionsIsValidCacheInitialized = true;
        if (valRes.results == null)
             model_internal::layer_c_dimensionsValidationFailureMessages_der = emptyArray;
        else
        {
            var _valFailures:Array = new Array();
            for (var a:int = 0 ; a<valRes.results.length ; a++)
            {
                _valFailures.push(valRes.results[a].errorMessage);
            }
            model_internal::layer_c_dimensionsValidationFailureMessages_der = _valFailures;
        }
    }

    [Bindable(event="propertyChange")]
    public function get layer_c_dimensionsValidationFailureMessages():Array
    {
        if (model_internal::_layer_c_dimensionsValidationFailureMessages == null)
            model_internal::calculateLayer_c_dimensionsIsValid();

        return _layer_c_dimensionsValidationFailureMessages;
    }

    model_internal function set layer_c_dimensionsValidationFailureMessages_der(value:Array) : void
    {
        var oldValue:Array = model_internal::_layer_c_dimensionsValidationFailureMessages;

        var needUpdate : Boolean = false;
        if (oldValue == null)
            needUpdate = true;
    
        // avoid firing the event when old and new value are different empty arrays
        if (!needUpdate && (oldValue !== value && (oldValue.length > 0 || value.length > 0)))
        {
            if (oldValue.length == value.length)
            {
                for (var a:int=0; a < oldValue.length; a++)
                {
                    if (oldValue[a] !== value[a])
                    {
                        needUpdate = true;
                        break;
                    }
                }
            }
            else
            {
                needUpdate = true;
            }
        }

        if (needUpdate)
        {
            model_internal::_layer_c_dimensionsValidationFailureMessages = value;   
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "layer_c_dimensionsValidationFailureMessages", oldValue, value));
            // Only execute calculateIsValid if it has been called before, to update the validationFailureMessages for
            // the entire entity.
            if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
            {
                model_internal::_instance.model_internal::isValid_der = model_internal::_instance.model_internal::calculateIsValid();
            }
        }
    }

    [Bindable(event="propertyChange")]   
    public function get constr_idStyle():com.adobe.fiber.styles.Style
    {
        return model_internal::_nullStyle;
    }

    [Bindable(event="propertyChange")]   
    public function get u_value_aStyle():com.adobe.fiber.styles.Style
    {
        return model_internal::_nullStyle;
    }

    [Bindable(event="propertyChange")]   
    public function get u_value_bStyle():com.adobe.fiber.styles.Style
    {
        return model_internal::_nullStyle;
    }

    [Bindable(event="propertyChange")]   
    public function get layer_b_namesStyle():com.adobe.fiber.styles.Style
    {
        return model_internal::_nullStyle;
    }

    public function get layer_b_namesValidator() : StyleValidator
    {
        return model_internal::_layer_b_namesValidator;
    }

    model_internal function set _layer_b_namesIsValid_der(value:Boolean):void 
    {
        var oldValue:Boolean = model_internal::_layer_b_namesIsValid;         
        if (oldValue !== value)
        {
            model_internal::_layer_b_namesIsValid = value;
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "layer_b_namesIsValid", oldValue, value));
        }                             
    }

    [Bindable(event="propertyChange")]
    public function get layer_b_namesIsValid():Boolean
    {
        if (!model_internal::_layer_b_namesIsValidCacheInitialized)
        {
            model_internal::calculateLayer_b_namesIsValid();
        }

        return model_internal::_layer_b_namesIsValid;
    }

    model_internal function calculateLayer_b_namesIsValid():void
    {
        var valRes:ValidationResultEvent = model_internal::_layer_b_namesValidator.validate(model_internal::_instance.layer_b_names)
        model_internal::_layer_b_namesIsValid_der = (valRes.results == null);
        model_internal::_layer_b_namesIsValidCacheInitialized = true;
        if (valRes.results == null)
             model_internal::layer_b_namesValidationFailureMessages_der = emptyArray;
        else
        {
            var _valFailures:Array = new Array();
            for (var a:int = 0 ; a<valRes.results.length ; a++)
            {
                _valFailures.push(valRes.results[a].errorMessage);
            }
            model_internal::layer_b_namesValidationFailureMessages_der = _valFailures;
        }
    }

    [Bindable(event="propertyChange")]
    public function get layer_b_namesValidationFailureMessages():Array
    {
        if (model_internal::_layer_b_namesValidationFailureMessages == null)
            model_internal::calculateLayer_b_namesIsValid();

        return _layer_b_namesValidationFailureMessages;
    }

    model_internal function set layer_b_namesValidationFailureMessages_der(value:Array) : void
    {
        var oldValue:Array = model_internal::_layer_b_namesValidationFailureMessages;

        var needUpdate : Boolean = false;
        if (oldValue == null)
            needUpdate = true;
    
        // avoid firing the event when old and new value are different empty arrays
        if (!needUpdate && (oldValue !== value && (oldValue.length > 0 || value.length > 0)))
        {
            if (oldValue.length == value.length)
            {
                for (var a:int=0; a < oldValue.length; a++)
                {
                    if (oldValue[a] !== value[a])
                    {
                        needUpdate = true;
                        break;
                    }
                }
            }
            else
            {
                needUpdate = true;
            }
        }

        if (needUpdate)
        {
            model_internal::_layer_b_namesValidationFailureMessages = value;   
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "layer_b_namesValidationFailureMessages", oldValue, value));
            // Only execute calculateIsValid if it has been called before, to update the validationFailureMessages for
            // the entire entity.
            if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
            {
                model_internal::_instance.model_internal::isValid_der = model_internal::_instance.model_internal::calculateIsValid();
            }
        }
    }

    [Bindable(event="propertyChange")]   
    public function get u_value_cStyle():com.adobe.fiber.styles.Style
    {
        return model_internal::_nullStyle;
    }

    [Bindable(event="propertyChange")]   
    public function get u_value_dStyle():com.adobe.fiber.styles.Style
    {
        return model_internal::_nullStyle;
    }

    [Bindable(event="propertyChange")]   
    public function get int_id_summaryStyle():com.adobe.fiber.styles.Style
    {
        return model_internal::_nullStyle;
    }

    public function get int_id_summaryValidator() : StyleValidator
    {
        return model_internal::_int_id_summaryValidator;
    }

    model_internal function set _int_id_summaryIsValid_der(value:Boolean):void 
    {
        var oldValue:Boolean = model_internal::_int_id_summaryIsValid;         
        if (oldValue !== value)
        {
            model_internal::_int_id_summaryIsValid = value;
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "int_id_summaryIsValid", oldValue, value));
        }                             
    }

    [Bindable(event="propertyChange")]
    public function get int_id_summaryIsValid():Boolean
    {
        if (!model_internal::_int_id_summaryIsValidCacheInitialized)
        {
            model_internal::calculateInt_id_summaryIsValid();
        }

        return model_internal::_int_id_summaryIsValid;
    }

    model_internal function calculateInt_id_summaryIsValid():void
    {
        var valRes:ValidationResultEvent = model_internal::_int_id_summaryValidator.validate(model_internal::_instance.int_id_summary)
        model_internal::_int_id_summaryIsValid_der = (valRes.results == null);
        model_internal::_int_id_summaryIsValidCacheInitialized = true;
        if (valRes.results == null)
             model_internal::int_id_summaryValidationFailureMessages_der = emptyArray;
        else
        {
            var _valFailures:Array = new Array();
            for (var a:int = 0 ; a<valRes.results.length ; a++)
            {
                _valFailures.push(valRes.results[a].errorMessage);
            }
            model_internal::int_id_summaryValidationFailureMessages_der = _valFailures;
        }
    }

    [Bindable(event="propertyChange")]
    public function get int_id_summaryValidationFailureMessages():Array
    {
        if (model_internal::_int_id_summaryValidationFailureMessages == null)
            model_internal::calculateInt_id_summaryIsValid();

        return _int_id_summaryValidationFailureMessages;
    }

    model_internal function set int_id_summaryValidationFailureMessages_der(value:Array) : void
    {
        var oldValue:Array = model_internal::_int_id_summaryValidationFailureMessages;

        var needUpdate : Boolean = false;
        if (oldValue == null)
            needUpdate = true;
    
        // avoid firing the event when old and new value are different empty arrays
        if (!needUpdate && (oldValue !== value && (oldValue.length > 0 || value.length > 0)))
        {
            if (oldValue.length == value.length)
            {
                for (var a:int=0; a < oldValue.length; a++)
                {
                    if (oldValue[a] !== value[a])
                    {
                        needUpdate = true;
                        break;
                    }
                }
            }
            else
            {
                needUpdate = true;
            }
        }

        if (needUpdate)
        {
            model_internal::_int_id_summaryValidationFailureMessages = value;   
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "int_id_summaryValidationFailureMessages", oldValue, value));
            // Only execute calculateIsValid if it has been called before, to update the validationFailureMessages for
            // the entire entity.
            if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
            {
                model_internal::_instance.model_internal::isValid_der = model_internal::_instance.model_internal::calculateIsValid();
            }
        }
    }

    [Bindable(event="propertyChange")]   
    public function get systemStyle():com.adobe.fiber.styles.Style
    {
        return model_internal::_nullStyle;
    }

    public function get systemValidator() : StyleValidator
    {
        return model_internal::_systemValidator;
    }

    model_internal function set _systemIsValid_der(value:Boolean):void 
    {
        var oldValue:Boolean = model_internal::_systemIsValid;         
        if (oldValue !== value)
        {
            model_internal::_systemIsValid = value;
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "systemIsValid", oldValue, value));
        }                             
    }

    [Bindable(event="propertyChange")]
    public function get systemIsValid():Boolean
    {
        if (!model_internal::_systemIsValidCacheInitialized)
        {
            model_internal::calculateSystemIsValid();
        }

        return model_internal::_systemIsValid;
    }

    model_internal function calculateSystemIsValid():void
    {
        var valRes:ValidationResultEvent = model_internal::_systemValidator.validate(model_internal::_instance.system)
        model_internal::_systemIsValid_der = (valRes.results == null);
        model_internal::_systemIsValidCacheInitialized = true;
        if (valRes.results == null)
             model_internal::systemValidationFailureMessages_der = emptyArray;
        else
        {
            var _valFailures:Array = new Array();
            for (var a:int = 0 ; a<valRes.results.length ; a++)
            {
                _valFailures.push(valRes.results[a].errorMessage);
            }
            model_internal::systemValidationFailureMessages_der = _valFailures;
        }
    }

    [Bindable(event="propertyChange")]
    public function get systemValidationFailureMessages():Array
    {
        if (model_internal::_systemValidationFailureMessages == null)
            model_internal::calculateSystemIsValid();

        return _systemValidationFailureMessages;
    }

    model_internal function set systemValidationFailureMessages_der(value:Array) : void
    {
        var oldValue:Array = model_internal::_systemValidationFailureMessages;

        var needUpdate : Boolean = false;
        if (oldValue == null)
            needUpdate = true;
    
        // avoid firing the event when old and new value are different empty arrays
        if (!needUpdate && (oldValue !== value && (oldValue.length > 0 || value.length > 0)))
        {
            if (oldValue.length == value.length)
            {
                for (var a:int=0; a < oldValue.length; a++)
                {
                    if (oldValue[a] !== value[a])
                    {
                        needUpdate = true;
                        break;
                    }
                }
            }
            else
            {
                needUpdate = true;
            }
        }

        if (needUpdate)
        {
            model_internal::_systemValidationFailureMessages = value;   
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "systemValidationFailureMessages", oldValue, value));
            // Only execute calculateIsValid if it has been called before, to update the validationFailureMessages for
            // the entire entity.
            if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
            {
                model_internal::_instance.model_internal::isValid_der = model_internal::_instance.model_internal::calculateIsValid();
            }
        }
    }

    [Bindable(event="propertyChange")]   
    public function get nameStyle():com.adobe.fiber.styles.Style
    {
        return model_internal::_nullStyle;
    }

    public function get nameValidator() : StyleValidator
    {
        return model_internal::_nameValidator;
    }

    model_internal function set _nameIsValid_der(value:Boolean):void 
    {
        var oldValue:Boolean = model_internal::_nameIsValid;         
        if (oldValue !== value)
        {
            model_internal::_nameIsValid = value;
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "nameIsValid", oldValue, value));
        }                             
    }

    [Bindable(event="propertyChange")]
    public function get nameIsValid():Boolean
    {
        if (!model_internal::_nameIsValidCacheInitialized)
        {
            model_internal::calculateNameIsValid();
        }

        return model_internal::_nameIsValid;
    }

    model_internal function calculateNameIsValid():void
    {
        var valRes:ValidationResultEvent = model_internal::_nameValidator.validate(model_internal::_instance.name)
        model_internal::_nameIsValid_der = (valRes.results == null);
        model_internal::_nameIsValidCacheInitialized = true;
        if (valRes.results == null)
             model_internal::nameValidationFailureMessages_der = emptyArray;
        else
        {
            var _valFailures:Array = new Array();
            for (var a:int = 0 ; a<valRes.results.length ; a++)
            {
                _valFailures.push(valRes.results[a].errorMessage);
            }
            model_internal::nameValidationFailureMessages_der = _valFailures;
        }
    }

    [Bindable(event="propertyChange")]
    public function get nameValidationFailureMessages():Array
    {
        if (model_internal::_nameValidationFailureMessages == null)
            model_internal::calculateNameIsValid();

        return _nameValidationFailureMessages;
    }

    model_internal function set nameValidationFailureMessages_der(value:Array) : void
    {
        var oldValue:Array = model_internal::_nameValidationFailureMessages;

        var needUpdate : Boolean = false;
        if (oldValue == null)
            needUpdate = true;
    
        // avoid firing the event when old and new value are different empty arrays
        if (!needUpdate && (oldValue !== value && (oldValue.length > 0 || value.length > 0)))
        {
            if (oldValue.length == value.length)
            {
                for (var a:int=0; a < oldValue.length; a++)
                {
                    if (oldValue[a] !== value[a])
                    {
                        needUpdate = true;
                        break;
                    }
                }
            }
            else
            {
                needUpdate = true;
            }
        }

        if (needUpdate)
        {
            model_internal::_nameValidationFailureMessages = value;   
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "nameValidationFailureMessages", oldValue, value));
            // Only execute calculateIsValid if it has been called before, to update the validationFailureMessages for
            // the entire entity.
            if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
            {
                model_internal::_instance.model_internal::isValid_der = model_internal::_instance.model_internal::calculateIsValid();
            }
        }
    }

    [Bindable(event="propertyChange")]   
    public function get layer_c_namesStyle():com.adobe.fiber.styles.Style
    {
        return model_internal::_nullStyle;
    }

    public function get layer_c_namesValidator() : StyleValidator
    {
        return model_internal::_layer_c_namesValidator;
    }

    model_internal function set _layer_c_namesIsValid_der(value:Boolean):void 
    {
        var oldValue:Boolean = model_internal::_layer_c_namesIsValid;         
        if (oldValue !== value)
        {
            model_internal::_layer_c_namesIsValid = value;
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "layer_c_namesIsValid", oldValue, value));
        }                             
    }

    [Bindable(event="propertyChange")]
    public function get layer_c_namesIsValid():Boolean
    {
        if (!model_internal::_layer_c_namesIsValidCacheInitialized)
        {
            model_internal::calculateLayer_c_namesIsValid();
        }

        return model_internal::_layer_c_namesIsValid;
    }

    model_internal function calculateLayer_c_namesIsValid():void
    {
        var valRes:ValidationResultEvent = model_internal::_layer_c_namesValidator.validate(model_internal::_instance.layer_c_names)
        model_internal::_layer_c_namesIsValid_der = (valRes.results == null);
        model_internal::_layer_c_namesIsValidCacheInitialized = true;
        if (valRes.results == null)
             model_internal::layer_c_namesValidationFailureMessages_der = emptyArray;
        else
        {
            var _valFailures:Array = new Array();
            for (var a:int = 0 ; a<valRes.results.length ; a++)
            {
                _valFailures.push(valRes.results[a].errorMessage);
            }
            model_internal::layer_c_namesValidationFailureMessages_der = _valFailures;
        }
    }

    [Bindable(event="propertyChange")]
    public function get layer_c_namesValidationFailureMessages():Array
    {
        if (model_internal::_layer_c_namesValidationFailureMessages == null)
            model_internal::calculateLayer_c_namesIsValid();

        return _layer_c_namesValidationFailureMessages;
    }

    model_internal function set layer_c_namesValidationFailureMessages_der(value:Array) : void
    {
        var oldValue:Array = model_internal::_layer_c_namesValidationFailureMessages;

        var needUpdate : Boolean = false;
        if (oldValue == null)
            needUpdate = true;
    
        // avoid firing the event when old and new value are different empty arrays
        if (!needUpdate && (oldValue !== value && (oldValue.length > 0 || value.length > 0)))
        {
            if (oldValue.length == value.length)
            {
                for (var a:int=0; a < oldValue.length; a++)
                {
                    if (oldValue[a] !== value[a])
                    {
                        needUpdate = true;
                        break;
                    }
                }
            }
            else
            {
                needUpdate = true;
            }
        }

        if (needUpdate)
        {
            model_internal::_layer_c_namesValidationFailureMessages = value;   
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "layer_c_namesValidationFailureMessages", oldValue, value));
            // Only execute calculateIsValid if it has been called before, to update the validationFailureMessages for
            // the entire entity.
            if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
            {
                model_internal::_instance.model_internal::isValid_der = model_internal::_instance.model_internal::calculateIsValid();
            }
        }
    }

    [Bindable(event="propertyChange")]   
    public function get active_tabStyle():com.adobe.fiber.styles.Style
    {
        return model_internal::_nullStyle;
    }

    [Bindable(event="propertyChange")]   
    public function get layer_d_namesStyle():com.adobe.fiber.styles.Style
    {
        return model_internal::_nullStyle;
    }

    public function get layer_d_namesValidator() : StyleValidator
    {
        return model_internal::_layer_d_namesValidator;
    }

    model_internal function set _layer_d_namesIsValid_der(value:Boolean):void 
    {
        var oldValue:Boolean = model_internal::_layer_d_namesIsValid;         
        if (oldValue !== value)
        {
            model_internal::_layer_d_namesIsValid = value;
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "layer_d_namesIsValid", oldValue, value));
        }                             
    }

    [Bindable(event="propertyChange")]
    public function get layer_d_namesIsValid():Boolean
    {
        if (!model_internal::_layer_d_namesIsValidCacheInitialized)
        {
            model_internal::calculateLayer_d_namesIsValid();
        }

        return model_internal::_layer_d_namesIsValid;
    }

    model_internal function calculateLayer_d_namesIsValid():void
    {
        var valRes:ValidationResultEvent = model_internal::_layer_d_namesValidator.validate(model_internal::_instance.layer_d_names)
        model_internal::_layer_d_namesIsValid_der = (valRes.results == null);
        model_internal::_layer_d_namesIsValidCacheInitialized = true;
        if (valRes.results == null)
             model_internal::layer_d_namesValidationFailureMessages_der = emptyArray;
        else
        {
            var _valFailures:Array = new Array();
            for (var a:int = 0 ; a<valRes.results.length ; a++)
            {
                _valFailures.push(valRes.results[a].errorMessage);
            }
            model_internal::layer_d_namesValidationFailureMessages_der = _valFailures;
        }
    }

    [Bindable(event="propertyChange")]
    public function get layer_d_namesValidationFailureMessages():Array
    {
        if (model_internal::_layer_d_namesValidationFailureMessages == null)
            model_internal::calculateLayer_d_namesIsValid();

        return _layer_d_namesValidationFailureMessages;
    }

    model_internal function set layer_d_namesValidationFailureMessages_der(value:Array) : void
    {
        var oldValue:Array = model_internal::_layer_d_namesValidationFailureMessages;

        var needUpdate : Boolean = false;
        if (oldValue == null)
            needUpdate = true;
    
        // avoid firing the event when old and new value are different empty arrays
        if (!needUpdate && (oldValue !== value && (oldValue.length > 0 || value.length > 0)))
        {
            if (oldValue.length == value.length)
            {
                for (var a:int=0; a < oldValue.length; a++)
                {
                    if (oldValue[a] !== value[a])
                    {
                        needUpdate = true;
                        break;
                    }
                }
            }
            else
            {
                needUpdate = true;
            }
        }

        if (needUpdate)
        {
            model_internal::_layer_d_namesValidationFailureMessages = value;   
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "layer_d_namesValidationFailureMessages", oldValue, value));
            // Only execute calculateIsValid if it has been called before, to update the validationFailureMessages for
            // the entire entity.
            if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
            {
                model_internal::_instance.model_internal::isValid_der = model_internal::_instance.model_internal::calculateIsValid();
            }
        }
    }

    [Bindable(event="propertyChange")]   
    public function get layer_d_dimensionsStyle():com.adobe.fiber.styles.Style
    {
        return model_internal::_nullStyle;
    }

    public function get layer_d_dimensionsValidator() : StyleValidator
    {
        return model_internal::_layer_d_dimensionsValidator;
    }

    model_internal function set _layer_d_dimensionsIsValid_der(value:Boolean):void 
    {
        var oldValue:Boolean = model_internal::_layer_d_dimensionsIsValid;         
        if (oldValue !== value)
        {
            model_internal::_layer_d_dimensionsIsValid = value;
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "layer_d_dimensionsIsValid", oldValue, value));
        }                             
    }

    [Bindable(event="propertyChange")]
    public function get layer_d_dimensionsIsValid():Boolean
    {
        if (!model_internal::_layer_d_dimensionsIsValidCacheInitialized)
        {
            model_internal::calculateLayer_d_dimensionsIsValid();
        }

        return model_internal::_layer_d_dimensionsIsValid;
    }

    model_internal function calculateLayer_d_dimensionsIsValid():void
    {
        var valRes:ValidationResultEvent = model_internal::_layer_d_dimensionsValidator.validate(model_internal::_instance.layer_d_dimensions)
        model_internal::_layer_d_dimensionsIsValid_der = (valRes.results == null);
        model_internal::_layer_d_dimensionsIsValidCacheInitialized = true;
        if (valRes.results == null)
             model_internal::layer_d_dimensionsValidationFailureMessages_der = emptyArray;
        else
        {
            var _valFailures:Array = new Array();
            for (var a:int = 0 ; a<valRes.results.length ; a++)
            {
                _valFailures.push(valRes.results[a].errorMessage);
            }
            model_internal::layer_d_dimensionsValidationFailureMessages_der = _valFailures;
        }
    }

    [Bindable(event="propertyChange")]
    public function get layer_d_dimensionsValidationFailureMessages():Array
    {
        if (model_internal::_layer_d_dimensionsValidationFailureMessages == null)
            model_internal::calculateLayer_d_dimensionsIsValid();

        return _layer_d_dimensionsValidationFailureMessages;
    }

    model_internal function set layer_d_dimensionsValidationFailureMessages_der(value:Array) : void
    {
        var oldValue:Array = model_internal::_layer_d_dimensionsValidationFailureMessages;

        var needUpdate : Boolean = false;
        if (oldValue == null)
            needUpdate = true;
    
        // avoid firing the event when old and new value are different empty arrays
        if (!needUpdate && (oldValue !== value && (oldValue.length > 0 || value.length > 0)))
        {
            if (oldValue.length == value.length)
            {
                for (var a:int=0; a < oldValue.length; a++)
                {
                    if (oldValue[a] !== value[a])
                    {
                        needUpdate = true;
                        break;
                    }
                }
            }
            else
            {
                needUpdate = true;
            }
        }

        if (needUpdate)
        {
            model_internal::_layer_d_dimensionsValidationFailureMessages = value;   
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "layer_d_dimensionsValidationFailureMessages", oldValue, value));
            // Only execute calculateIsValid if it has been called before, to update the validationFailureMessages for
            // the entire entity.
            if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
            {
                model_internal::_instance.model_internal::isValid_der = model_internal::_instance.model_internal::calculateIsValid();
            }
        }
    }

    [Bindable(event="propertyChange")]   
    public function get layer_a_namesStyle():com.adobe.fiber.styles.Style
    {
        return model_internal::_nullStyle;
    }

    public function get layer_a_namesValidator() : StyleValidator
    {
        return model_internal::_layer_a_namesValidator;
    }

    model_internal function set _layer_a_namesIsValid_der(value:Boolean):void 
    {
        var oldValue:Boolean = model_internal::_layer_a_namesIsValid;         
        if (oldValue !== value)
        {
            model_internal::_layer_a_namesIsValid = value;
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "layer_a_namesIsValid", oldValue, value));
        }                             
    }

    [Bindable(event="propertyChange")]
    public function get layer_a_namesIsValid():Boolean
    {
        if (!model_internal::_layer_a_namesIsValidCacheInitialized)
        {
            model_internal::calculateLayer_a_namesIsValid();
        }

        return model_internal::_layer_a_namesIsValid;
    }

    model_internal function calculateLayer_a_namesIsValid():void
    {
        var valRes:ValidationResultEvent = model_internal::_layer_a_namesValidator.validate(model_internal::_instance.layer_a_names)
        model_internal::_layer_a_namesIsValid_der = (valRes.results == null);
        model_internal::_layer_a_namesIsValidCacheInitialized = true;
        if (valRes.results == null)
             model_internal::layer_a_namesValidationFailureMessages_der = emptyArray;
        else
        {
            var _valFailures:Array = new Array();
            for (var a:int = 0 ; a<valRes.results.length ; a++)
            {
                _valFailures.push(valRes.results[a].errorMessage);
            }
            model_internal::layer_a_namesValidationFailureMessages_der = _valFailures;
        }
    }

    [Bindable(event="propertyChange")]
    public function get layer_a_namesValidationFailureMessages():Array
    {
        if (model_internal::_layer_a_namesValidationFailureMessages == null)
            model_internal::calculateLayer_a_namesIsValid();

        return _layer_a_namesValidationFailureMessages;
    }

    model_internal function set layer_a_namesValidationFailureMessages_der(value:Array) : void
    {
        var oldValue:Array = model_internal::_layer_a_namesValidationFailureMessages;

        var needUpdate : Boolean = false;
        if (oldValue == null)
            needUpdate = true;
    
        // avoid firing the event when old and new value are different empty arrays
        if (!needUpdate && (oldValue !== value && (oldValue.length > 0 || value.length > 0)))
        {
            if (oldValue.length == value.length)
            {
                for (var a:int=0; a < oldValue.length; a++)
                {
                    if (oldValue[a] !== value[a])
                    {
                        needUpdate = true;
                        break;
                    }
                }
            }
            else
            {
                needUpdate = true;
            }
        }

        if (needUpdate)
        {
            model_internal::_layer_a_namesValidationFailureMessages = value;   
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "layer_a_namesValidationFailureMessages", oldValue, value));
            // Only execute calculateIsValid if it has been called before, to update the validationFailureMessages for
            // the entire entity.
            if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
            {
                model_internal::_instance.model_internal::isValid_der = model_internal::_instance.model_internal::calculateIsValid();
            }
        }
    }


     /**
     * 
     * @inheritDoc 
     */ 
     override public function getStyle(propertyName:String):com.adobe.fiber.styles.IStyle
     {
         switch(propertyName)
         {
            default:
            {
                return null;
            }
         }
     }
     
     /**
     * 
     * @inheritDoc 
     *  
     */  
     override public function getPropertyValidationFailureMessages(propertyName:String):Array
     {
         switch(propertyName)
         {
            case("partnerFS"):
            {
                return partnerFSValidationFailureMessages;
            }
            case("published"):
            {
                return publishedValidationFailureMessages;
            }
            case("int_id_climate"):
            {
                return int_id_climateValidationFailureMessages;
            }
            case("int_id_kind"):
            {
                return int_id_kindValidationFailureMessages;
            }
            case("int_id_static"):
            {
                return int_id_staticValidationFailureMessages;
            }
            case("int_id_facade"):
            {
                return int_id_facadeValidationFailureMessages;
            }
            case("int_id_joint"):
            {
                return int_id_jointValidationFailureMessages;
            }
            case("int_id_no"):
            {
                return int_id_noValidationFailureMessages;
            }
            case("int_id_localisation"):
            {
                return int_id_localisationValidationFailureMessages;
            }
            case("valid_since"):
            {
                return valid_sinceValidationFailureMessages;
            }
            case("valid_to"):
            {
                return valid_toValidationFailureMessages;
            }
            case("image"):
            {
                return imageValidationFailureMessages;
            }
            case("image_caption"):
            {
                return image_captionValidationFailureMessages;
            }
            case("url_dxf"):
            {
                return url_dxfValidationFailureMessages;
            }
            case("url_dwg"):
            {
                return url_dwgValidationFailureMessages;
            }
            case("url_pla"):
            {
                return url_plaValidationFailureMessages;
            }
            case("url_pdf"):
            {
                return url_pdfValidationFailureMessages;
            }
            case("url_jpg"):
            {
                return url_jpgValidationFailureMessages;
            }
            case("rw"):
            {
                return rwValidationFailureMessages;
            }
            case("lntw"):
            {
                return lntwValidationFailureMessages;
            }
            case("notes"):
            {
                return notesValidationFailureMessages;
            }
            case("physics"):
            {
                return physicsValidationFailureMessages;
            }
            case("add_notes"):
            {
                return add_notesValidationFailureMessages;
            }
            case("rel_info"):
            {
                return rel_infoValidationFailureMessages;
            }
            case("layer_a_dimensions"):
            {
                return layer_a_dimensionsValidationFailureMessages;
            }
            case("layer_b_dimensions"):
            {
                return layer_b_dimensionsValidationFailureMessages;
            }
            case("layer_c_dimensions"):
            {
                return layer_c_dimensionsValidationFailureMessages;
            }
            case("layer_b_names"):
            {
                return layer_b_namesValidationFailureMessages;
            }
            case("int_id_summary"):
            {
                return int_id_summaryValidationFailureMessages;
            }
            case("system"):
            {
                return systemValidationFailureMessages;
            }
            case("name"):
            {
                return nameValidationFailureMessages;
            }
            case("layer_c_names"):
            {
                return layer_c_namesValidationFailureMessages;
            }
            case("layer_d_names"):
            {
                return layer_d_namesValidationFailureMessages;
            }
            case("layer_d_dimensions"):
            {
                return layer_d_dimensionsValidationFailureMessages;
            }
            case("layer_a_names"):
            {
                return layer_a_namesValidationFailureMessages;
            }
            default:
            {
                return emptyArray;
            }
         }
     }

}

}
